diff --git a/grammar.js b/grammar.js index 0df727b..733c4b7 100644 --- a/grammar.js +++ b/grammar.js @@ -31,7 +31,9 @@ module.exports = grammar({ $.buffer_definition, $.query_definition, $.temp_table_definition - ] + ], + [$.property_definition, $.temp_table_definition], + [$.temp_table_definition, $.dataset_definition] ], rules: { @@ -191,6 +193,7 @@ module.exports = grammar({ /// Primitives primitive_type: ($) => choice( + kw("VOID"), kw("LOGICAL"), kw("INTEGER"), kw("INT"), @@ -410,9 +413,9 @@ module.exports = grammar({ function_parameter: ($) => seq( optional($.function_parameter_mode), + optional(kw("DATASET")), $.identifier, - kw("AS"), - $.primitive_type + choice(seq(kw("AS"), $.primitive_type), kw("BIND")) ), function_statement: ($) => @@ -432,7 +435,99 @@ module.exports = grammar({ return_statement: ($) => seq(kw("RETURN"), optional($._expression), $._terminator), - /// Classes + /// OOP + interface_body: ($) => + repeat1( + choice( + $.property_definition, + $.temp_table_definition, + $.event_definition, + $.method_definition, + $.dataset_definition + ) + ), + interface_statement: ($) => + seq( + kw("INTERFACE"), + field( + "name", + choice($._string_literal, $.identifier, $.qualified_name) + ), + optional($.inherits), + ":", + choice(seq($.interface_body, kw("END")), kw("END")), + optional(kw("INTERFACE")), + $._terminator + ), + + property_tuning: ($) => choice(kw("ABSTRACT"), kw("OVERRIDE")), + getter: ($) => seq(optional($.access_tuning), kw("GET"), $._terminator), + setter: ($) => seq(optional($.access_tuning), kw("SET"), $._terminator), + property_definition: ($) => + seq( + kw("DEFINE"), + optional($.access_tuning), + repeat($.property_tuning), + optional($.serialization_tuning), + kw("PROPERTY"), + $.identifier, + choice( + seq(kw("AS"), $.primitive_type), + seq(kw("LIKE"), field("like", choice($.identifier, $.qualified_name))) + ), + optional(seq(kw("EXTENT"), $.number_literal)), + optional(kw("NO-UNDO")), + repeat(choice($.getter, $.setter)) + ), + + event_definition: ($) => + seq( + kw("DEFINE"), + optional($.access_tuning), + repeat($.property_tuning), + kw("EVENT"), + $.identifier, + optional(kw("SIGNATURE")), + kw("VOID"), + seq("(", optional(_list($.function_parameter, ",")), ")"), + $._terminator + ), + + method_definition: ($) => + seq( + kw("METHOD"), + optional($.access_tuning), + field("return_type", $.primitive_type), + $.identifier, + seq("(", optional(_list($.function_parameter, ",")), ")"), + $._terminator + ), + + data_relation: ($) => + seq( + kw("DATA-RELATION"), + kw("FOR"), + _list(choice($.identifier, $.qualified_name), ","), + kw("RELATION-FIELDS"), + seq( + "(", + optional(_list(choice($.identifier, $.qualified_name), ",")), + ")" + ) + ), + dataset_definition: ($) => + seq( + kw("DEFINE"), + optional($.scope_tuning), + optional($.access_tuning), + kw("DATASET"), + $.identifier, + kw("FOR"), + _list(choice($.identifier, $.qualified_name), ","), + $.data_relation, + $._terminator + ), + class_statement: ($) => seq( kw("CLASS"), @@ -442,13 +537,7 @@ module.exports = grammar({ ), repeat( choice( - seq( - kw("INHERITS"), - field( - "inherits", - choice($._string_literal, $.identifier, $.qualified_name) - ) - ), + $.inherits, $.implements, $.use_widget_pool, $.abstract, @@ -463,6 +552,12 @@ module.exports = grammar({ $._terminator ), + inherits: ($) => + seq( + kw("INHERITS"), + _list(choice($._string_literal, $.identifier, $.qualified_name), ",") + ), + implements: ($) => seq( kw("IMPLEMENTS"), @@ -1002,7 +1097,6 @@ module.exports = grammar({ $.function_statement, $.function_call_statement, $.return_statement, - $.class_statement, $.if_statement, $._loop_statement, $.for_statement, @@ -1019,6 +1113,8 @@ module.exports = grammar({ $.undo_statement, $.error_scope_statement, $.temp_table_definition, + $.class_statement, + $.interface_statement, $.on_statement, $.abl_statement, prec.left(PREC.EXTRA, $.label) diff --git a/src/grammar.json b/src/grammar.json index 0741a11..cd4bc14 100644 --- a/src/grammar.json +++ b/src/grammar.json @@ -1158,6 +1158,22 @@ "primitive_type": { "type": "CHOICE", "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[vV][oO][iI][dD]" + } + } + }, + "named": false, + "value": "VOID" + }, { "type": "ALIAS", "content": { @@ -2840,10 +2856,6 @@ { "type": "SYMBOL", "name": "do_while_statement" - }, - { - "type": "SYMBOL", - "name": "do_statement" } ] }, @@ -3034,83 +3046,6 @@ } ] }, - "do_statement": { - "type": "SEQ", - "members": [ - { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "label" - }, - { - "type": "BLANK" - } - ] - }, - { - "type": "ALIAS", - "content": { - "type": "TOKEN", - "content": { - "type": "PREC", - "value": 1, - "content": { - "type": "PATTERN", - "value": "[dD][oO]" - } - } - }, - "named": false, - "value": "DO" - }, - { - "type": "SYMBOL", - "name": "assignment" - }, - { - "type": "ALIAS", - "content": { - "type": "TOKEN", - "content": { - "type": "PREC", - "value": 1, - "content": { - "type": "PATTERN", - "value": "[tT][oO]" - } - } - }, - "named": false, - "value": "TO" - }, - { - "type": "SYMBOL", - "name": "_expression" - }, - { - "type": "STRING", - "value": ":" - }, - { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "body" - }, - { - "type": "BLANK" - } - ] - }, - { - "type": "SYMBOL", - "name": "_block_terminator" - } - ] - }, "_procedure_terminator": { "type": "SEQ", "members": [ @@ -3473,29 +3408,79 @@ } ] }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][aA][tT][aA][sS][eE][tT]" + } + } + }, + "named": false, + "value": "DATASET" + }, + { + "type": "BLANK" + } + ] + }, { "type": "SYMBOL", "name": "identifier" }, { - "type": "ALIAS", - "content": { - "type": "TOKEN", - "content": { - "type": "PREC", - "value": 1, + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[aA][sS]" + } + } + }, + "named": false, + "value": "AS" + }, + { + "type": "SYMBOL", + "name": "primitive_type" + } + ] + }, + { + "type": "ALIAS", "content": { - "type": "PATTERN", - "value": "[aA][sS]" - } + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[bB][iI][nN][dD]" + } + } + }, + "named": false, + "value": "BIND" } - }, - "named": false, - "value": "AS" - }, - { - "type": "SYMBOL", - "name": "primitive_type" + ] } ] }, @@ -3690,7 +3675,35 @@ } ] }, - "class_statement": { + "interface_body": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "property_definition" + }, + { + "type": "SYMBOL", + "name": "temp_table_definition" + }, + { + "type": "SYMBOL", + "name": "event_definition" + }, + { + "type": "SYMBOL", + "name": "method_definition" + }, + { + "type": "SYMBOL", + "name": "dataset_definition" + } + ] + } + }, + "interface_statement": { "type": "SEQ", "members": [ { @@ -3702,12 +3715,12 @@ "value": 1, "content": { "type": "PATTERN", - "value": "[cC][lL][aA][sS][sS]" + "value": "[iI][nN][tT][eE][rR][fF][aA][cC][eE]" } } }, "named": false, - "value": "CLASS" + "value": "INTERFACE" }, { "type": "FIELD", @@ -3731,51 +3744,1006 @@ } }, { - "type": "REPEAT", - "content": { - "type": "CHOICE", - "members": [ - { - "type": "SEQ", - "members": [ - { - "type": "ALIAS", + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "inherits" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "interface_body" + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", "content": { - "type": "TOKEN", + "type": "PREC", + "value": 1, "content": { - "type": "PREC", - "value": 1, - "content": { - "type": "PATTERN", - "value": "[iI][nN][hH][eE][rR][iI][tT][sS]" - } + "type": "PATTERN", + "value": "[eE][nN][dD]" } - }, - "named": false, - "value": "INHERITS" + } }, - { - "type": "FIELD", - "name": "inherits", - "content": { - "type": "CHOICE", - "members": [ - { - "type": "SYMBOL", - "name": "_string_literal" - }, - { - "type": "SYMBOL", - "name": "identifier" - }, + "named": false, + "value": "END" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[eE][nN][dD]" + } + } + }, + "named": false, + "value": "END" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[iI][nN][tT][eE][rR][fF][aA][cC][eE]" + } + } + }, + "named": false, + "value": "INTERFACE" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "property_tuning": { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[aA][bB][sS][tT][rR][aA][cC][tT]" + } + } + }, + "named": false, + "value": "ABSTRACT" + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[oO][vV][eE][rR][rR][iI][dD][eE]" + } + } + }, + "named": false, + "value": "OVERRIDE" + } + ] + }, + "getter": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[gG][eE][tT]" + } + } + }, + "named": false, + "value": "GET" + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "setter": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[sS][eE][tT]" + } + } + }, + "named": false, + "value": "SET" + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "property_definition": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][eE][fF][iI][nN][eE]" + } + } + }, + "named": false, + "value": "DEFINE" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "property_tuning" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "serialization_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[pP][rR][oO][pP][eE][rR][tT][yY]" + } + } + }, + "named": false, + "value": "PROPERTY" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[aA][sS]" + } + } + }, + "named": false, + "value": "AS" + }, + { + "type": "SYMBOL", + "name": "primitive_type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[lL][iI][kK][eE]" + } + } + }, + "named": false, + "value": "LIKE" + }, + { + "type": "FIELD", + "name": "like", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + } + } + ] + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[eE][xX][tT][eE][nN][tT]" + } + } + }, + "named": false, + "value": "EXTENT" + }, + { + "type": "SYMBOL", + "name": "number_literal" + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[nN][oO][--][uU][nN][dD][oO]" + } + } + }, + "named": false, + "value": "NO-UNDO" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "getter" + }, + { + "type": "SYMBOL", + "name": "setter" + } + ] + } + } + ] + }, + "event_definition": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][eE][fF][iI][nN][eE]" + } + } + }, + "named": false, + "value": "DEFINE" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "property_tuning" + } + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[eE][vV][eE][nN][tT]" + } + } + }, + "named": false, + "value": "EVENT" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[sS][iI][gG][nN][aA][tT][uU][rR][eE]" + } + } + }, + "named": false, + "value": "SIGNATURE" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[vV][oO][iI][dD]" + } + } + }, + "named": false, + "value": "VOID" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "function_parameter" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "function_parameter" + } + ] + } + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "method_definition": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[mM][eE][tT][hH][oO][dD]" + } + } + }, + "named": false, + "value": "METHOD" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "FIELD", + "name": "return_type", + "content": { + "type": "SYMBOL", + "name": "primitive_type" + } + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "function_parameter" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "function_parameter" + } + ] + } + } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "data_relation": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][aA][tT][aA][--][rR][eE][lL][aA][tT][iI][oO][nN]" + } + } + }, + "named": false, + "value": "DATA-RELATION" + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[fF][oO][rR]" + } + } + }, + "named": false, + "value": "FOR" + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + } + ] + } + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[rR][eE][lL][aA][tT][iI][oO][nN][--][fF][iI][eE][lL][dD][sS]" + } + } + }, + "named": false, + "value": "RELATION-FIELDS" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, { "type": "SYMBOL", "name": "qualified_name" } ] + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + } + ] + } } + ] + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + }, + "dataset_definition": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][eE][fF][iI][nN][eE]" + } + } + }, + "named": false, + "value": "DEFINE" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "scope_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "access_tuning" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[dD][aA][tT][aA][sS][eE][tT]" + } + } + }, + "named": false, + "value": "DATASET" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[fF][oO][rR]" + } + } + }, + "named": false, + "value": "FOR" + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] } ] + } + } + ] + }, + { + "type": "SYMBOL", + "name": "data_relation" + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "class_statement": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[cC][lL][aA][sS][sS]" + } + } + }, + "named": false, + "value": "CLASS" + }, + { + "type": "FIELD", + "name": "name", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_string_literal" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + } + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "inherits" }, { "type": "SYMBOL", @@ -3847,18 +4815,90 @@ "value": "[cC][lL][aA][sS][sS]" } } - }, - "named": false, - "value": "CLASS" + }, + "named": false, + "value": "CLASS" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "_terminator" + } + ] + }, + "inherits": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[iI][nN][hH][eE][rR][iI][tT][sS]" + } + } + }, + "named": false, + "value": "INHERITS" + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_string_literal" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] }, { - "type": "BLANK" + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_string_literal" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "qualified_name" + } + ] + } + ] + } } ] - }, - { - "type": "SYMBOL", - "name": "_terminator" } ] }, @@ -5413,9 +6453,131 @@ } ] }, + "stop_after_phrase": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[sS][tT][oO][pP][--][aA][fF][tT][eE][rR]" + } + } + }, + "named": false, + "value": "STOP-AFTER" + }, + { + "type": "SYMBOL", + "name": "_expression" + } + ] + }, + "do_tuning": { + "type": "CHOICE", + "members": [ + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[tT][rR][aA][nN][sS][aA][cC][tT][iI][oO][nN]" + } + } + }, + "named": false, + "value": "TRANSACTION" + } + ] + }, + "to_phrase": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "assignment" + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[tT][oO]" + } + } + }, + "named": false, + "value": "TO" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_expression" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "BY" + }, + { + "type": "SYMBOL", + "name": "number_literal" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + } + ] + }, "do_block": { "type": "SEQ", "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "label" + }, + { + "type": "BLANK" + } + ] + }, { "type": "ALIAS", "content": { @@ -5432,6 +6594,37 @@ "named": false, "value": "DO" }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "to_phrase" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "do_tuning" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "stop_after_phrase" + }, + { + "type": "BLANK" + } + ] + }, { "type": "CHOICE", "members": [ @@ -8650,36 +9843,40 @@ ] }, "widget_phrase": { - "type": "SEQ", - "members": [ - { - "type": "ALIAS", - "content": { - "type": "TOKEN", + "type": "PREC_LEFT", + "value": 0, + "content": { + "type": "SEQ", + "members": [ + { + "type": "ALIAS", "content": { - "type": "PREC", - "value": 1, + "type": "TOKEN", "content": { - "type": "PATTERN", - "value": "[fF][rR][aA][mM][eE]" + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[fF][rR][aA][mM][eE]" + } } - } + }, + "named": false, + "value": "FRAME" }, - "named": false, - "value": "FRAME" - }, - { - "type": "SYMBOL", - "name": "identifier" - }, - { - "type": "REPEAT", - "content": { + { "type": "SYMBOL", - "name": "widget_field" + "name": "identifier" + }, + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "widget_field" + } } - } - ] + ] + } }, "on_statement": { "type": "SEQ", @@ -8959,10 +10156,6 @@ "type": "SYMBOL", "name": "return_statement" }, - { - "type": "SYMBOL", - "name": "class_statement" - }, { "type": "SYMBOL", "name": "if_statement" @@ -8979,10 +10172,6 @@ "type": "SYMBOL", "name": "find_statement" }, - { - "type": "SYMBOL", - "name": "transaction_statement" - }, { "type": "SYMBOL", "name": "_stream_statement" @@ -9031,6 +10220,14 @@ "type": "SYMBOL", "name": "temp_table_definition" }, + { + "type": "SYMBOL", + "name": "class_statement" + }, + { + "type": "SYMBOL", + "name": "interface_statement" + }, { "type": "SYMBOL", "name": "on_statement" @@ -9070,6 +10267,14 @@ "buffer_definition", "query_definition", "temp_table_definition" + ], + [ + "property_definition", + "temp_table_definition" + ], + [ + "temp_table_definition", + "dataset_definition" ] ], "precedences": [], diff --git a/src/node-types.json b/src/node-types.json index 9e6a20f..9c733cf 100644 --- a/src/node-types.json +++ b/src/node-types.json @@ -141,10 +141,6 @@ "type": "do_block", "named": true }, - { - "type": "do_statement", - "named": true - }, { "type": "do_while_statement", "named": true @@ -185,6 +181,10 @@ "type": "input_stream_statement", "named": true }, + { + "type": "interface_statement", + "named": true + }, { "type": "label", "named": true @@ -229,10 +229,6 @@ "type": "temp_table_definition", "named": true }, - { - "type": "transaction_statement", - "named": true - }, { "type": "undo_statement", "named": true @@ -702,28 +698,6 @@ "type": "class_statement", "named": true, "fields": { - "inherits": { - "multiple": true, - "required": false, - "types": [ - { - "type": "double_quoted_string", - "named": true - }, - { - "type": "identifier", - "named": true - }, - { - "type": "qualified_name", - "named": true - }, - { - "type": "single_quoted_string", - "named": true - } - ] - }, "name": { "multiple": false, "required": true, @@ -767,6 +741,10 @@ "type": "implements", "named": true }, + { + "type": "inherits", + "named": true + }, { "type": "serializable", "named": true @@ -829,59 +807,103 @@ } }, { - "type": "do_block", + "type": "data_relation", "named": true, "fields": {}, "children": { "multiple": true, - "required": false, + "required": true, "types": [ { - "type": "body", + "type": "identifier", "named": true }, { - "type": "on_error_phrase", + "type": "qualified_name", + "named": true + } + ] + } + }, + { + "type": "dataset_definition", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "access_tuning", "named": true }, { - "type": "on_quit_phrase", + "type": "data_relation", "named": true }, { - "type": "on_stop_phrase", + "type": "identifier", + "named": true + }, + { + "type": "qualified_name", + "named": true + }, + { + "type": "scope_tuning", "named": true } ] } }, { - "type": "do_statement", + "type": "do_block", "named": true, "fields": {}, "children": { "multiple": true, - "required": true, + "required": false, "types": [ { - "type": "_expression", + "type": "body", "named": true }, { - "type": "assignment", + "type": "do_tuning", "named": true }, { - "type": "body", + "type": "label", "named": true }, { - "type": "label", + "type": "on_error_phrase", + "named": true + }, + { + "type": "on_quit_phrase", + "named": true + }, + { + "type": "on_stop_phrase", + "named": true + }, + { + "type": "stop_after_phrase", + "named": true + }, + { + "type": "to_phrase", "named": true } ] } }, + { + "type": "do_tuning", + "named": true, + "fields": {} + }, { "type": "do_while_statement", "named": true, @@ -1021,6 +1043,33 @@ ] } }, + { + "type": "event_definition", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "access_tuning", + "named": true + }, + { + "type": "function_parameter", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "property_tuning", + "named": true + } + ] + } + }, { "type": "field_definition", "named": true, @@ -1442,6 +1491,21 @@ ] } }, + { + "type": "getter", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "access_tuning", + "named": true + } + ] + } + }, { "type": "if_statement", "named": true, @@ -1610,6 +1674,33 @@ "named": true, "fields": {} }, + { + "type": "inherits", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "double_quoted_string", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "qualified_name", + "named": true + }, + { + "type": "single_quoted_string", + "named": true + } + ] + } + }, { "type": "input_close_statement", "named": true, @@ -1692,6 +1783,79 @@ } } }, + { + "type": "interface_body", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "dataset_definition", + "named": true + }, + { + "type": "event_definition", + "named": true + }, + { + "type": "method_definition", + "named": true + }, + { + "type": "property_definition", + "named": true + }, + { + "type": "temp_table_definition", + "named": true + } + ] + } + }, + { + "type": "interface_statement", + "named": true, + "fields": { + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "double_quoted_string", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "qualified_name", + "named": true + }, + { + "type": "single_quoted_string", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "inherits", + "named": true + }, + { + "type": "interface_body", + "named": true + } + ] + } + }, { "type": "label", "named": true, @@ -1737,6 +1901,40 @@ ] } }, + { + "type": "method_definition", + "named": true, + "fields": { + "return_type": { + "multiple": false, + "required": true, + "types": [ + { + "type": "primitive_type", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "access_tuning", + "named": true + }, + { + "type": "function_parameter", + "named": true + }, + { + "type": "identifier", + "named": true + } + ] + } + }, { "type": "multiplicative_expression", "named": true, @@ -2040,6 +2238,69 @@ ] } }, + { + "type": "property_definition", + "named": true, + "fields": { + "like": { + "multiple": false, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "qualified_name", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "access_tuning", + "named": true + }, + { + "type": "getter", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "primitive_type", + "named": true + }, + { + "type": "property_tuning", + "named": true + }, + { + "type": "serialization_tuning", + "named": true + }, + { + "type": "setter", + "named": true + } + ] + } + }, + { + "type": "property_tuning", + "named": true, + "fields": {} + }, { "type": "qualified_name", "named": true, @@ -2214,6 +2475,21 @@ "named": true, "fields": {} }, + { + "type": "setter", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "access_tuning", + "named": true + } + ] + } + }, { "type": "single_quoted_string", "named": true, @@ -2288,6 +2564,21 @@ ] } }, + { + "type": "stop_after_phrase", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "_expression", + "named": true + } + ] + } + }, { "type": "stream_definition", "named": true, @@ -2402,15 +2693,19 @@ } }, { - "type": "transaction_statement", + "type": "to_phrase", "named": true, "fields": {}, "children": { - "multiple": false, - "required": false, + "multiple": true, + "required": true, "types": [ { - "type": "body", + "type": "_expression", + "named": true + }, + { + "type": "assignment", "named": true } ] @@ -2790,6 +3085,10 @@ "type": "BEGINS", "named": false }, + { + "type": "BIND", + "named": false + }, { "type": "BLOCK-LEVEL", "named": false @@ -2862,6 +3161,14 @@ "type": "CURRENT-CHANGED", "named": false }, + { + "type": "DATA-RELATION", + "named": false + }, + { + "type": "DATASET", + "named": false + }, { "type": "DATE", "named": false @@ -2922,6 +3229,10 @@ "type": "ERROR", "named": false }, + { + "type": "EVENT", + "named": false + }, { "type": "EXCEPT", "named": false @@ -2986,6 +3297,10 @@ "type": "GE", "named": false }, + { + "type": "GET", + "named": false + }, { "type": "GLOBAL", "named": false @@ -3042,6 +3357,10 @@ "type": "INTEGER", "named": false }, + { + "type": "INTERFACE", + "named": false + }, { "type": "IS", "named": false @@ -3094,6 +3413,10 @@ "type": "MEMPTR", "named": false }, + { + "type": "METHOD", + "named": false + }, { "type": "MINIMUM", "named": false @@ -3158,6 +3481,10 @@ "type": "OUTPUT", "named": false }, + { + "type": "OVERRIDE", + "named": false + }, { "type": "PARAMETER", "named": false @@ -3178,6 +3505,10 @@ "type": "PROCEDURE", "named": false }, + { + "type": "PROPERTY", + "named": false + }, { "type": "PROTECTED", "named": false @@ -3210,6 +3541,10 @@ "type": "REFERENCE-ONLY", "named": false }, + { + "type": "RELATION-FIELDS", + "named": false + }, { "type": "REPEAT", "named": false @@ -3242,6 +3577,10 @@ "type": "SERIALIZABLE", "named": false }, + { + "type": "SET", + "named": false + }, { "type": "SHARE-LOCK", "named": false @@ -3250,6 +3589,10 @@ "type": "SHARED", "named": false }, + { + "type": "SIGNATURE", + "named": false + }, { "type": "STATIC", "named": false @@ -3258,6 +3601,10 @@ "type": "STOP", "named": false }, + { + "type": "STOP-AFTER", + "named": false + }, { "type": "STREAM", "named": false @@ -3342,6 +3689,10 @@ "type": "VARIABLE", "named": false }, + { + "type": "VOID", + "named": false + }, { "type": "WHEN", "named": false diff --git a/src/parser.c b/src/parser.c index d5ed187..4bc0df0 100644 --- a/src/parser.c +++ b/src/parser.c @@ -14,15 +14,15 @@ #endif #define LANGUAGE_VERSION 14 -#define STATE_COUNT 3318 -#define LARGE_STATE_COUNT 283 -#define SYMBOL_COUNT 365 +#define STATE_COUNT 3814 +#define LARGE_STATE_COUNT 300 +#define SYMBOL_COUNT 397 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 203 +#define TOKEN_COUNT 218 #define EXTERNAL_TOKEN_COUNT 1 -#define FIELD_COUNT 25 +#define FIELD_COUNT 24 #define MAX_ALIAS_SEQUENCE_LENGTH 16 -#define PRODUCTION_ID_COUNT 58 +#define PRODUCTION_ID_COUNT 61 enum { sym_identifier = 1, @@ -100,295 +100,327 @@ enum { aux_sym_primitive_type_token15 = 73, aux_sym_primitive_type_token16 = 74, aux_sym_primitive_type_token17 = 75, - aux_sym_variable_tuning_token1 = 76, - aux_sym_variable_tuning_token2 = 77, - aux_sym_variable_tuning_token3 = 78, - aux_sym_variable_tuning_token4 = 79, - aux_sym_variable_tuning_token5 = 80, - aux_sym_variable_tuning_token6 = 81, - aux_sym_scope_tuning_token1 = 82, - aux_sym_scope_tuning_token2 = 83, - aux_sym_scope_tuning_token3 = 84, - aux_sym_scope_tuning_token4 = 85, - aux_sym_access_tuning_token1 = 86, - aux_sym_access_tuning_token2 = 87, - aux_sym_access_tuning_token3 = 88, - aux_sym_serialization_tuning_token1 = 89, - aux_sym_serialization_tuning_token2 = 90, - aux_sym_variable_definition_token1 = 91, - aux_sym_variable_definition_token2 = 92, - aux_sym_variable_definition_token3 = 93, - aux_sym_variable_definition_token4 = 94, - aux_sym_variable_definition_token5 = 95, - aux_sym_variable_definition_token6 = 96, - aux_sym_buffer_definition_token1 = 97, - aux_sym_buffer_definition_token2 = 98, - aux_sym_buffer_definition_token3 = 99, - aux_sym_query_definition_tuning_token1 = 100, - anon_sym_SCROLLING = 101, - aux_sym_query_definition_tuning_token2 = 102, - aux_sym_query_definition_token1 = 103, - aux_sym_query_definition_token2 = 104, - aux_sym_query_definition_token3 = 105, - anon_sym_COMMA = 106, - aux_sym_argument_mode_token1 = 107, - aux_sym_argument_mode_token2 = 108, - aux_sym_if_statement_token1 = 109, - aux_sym_if_statement_token2 = 110, - aux_sym_else_if_statement_token1 = 111, - anon_sym_COLON = 112, - aux_sym__while_condition_token1 = 113, - aux_sym_repeat_statement_token1 = 114, - aux_sym_do_while_statement_token1 = 115, - aux_sym_do_statement_token1 = 116, + aux_sym_primitive_type_token18 = 76, + aux_sym_variable_tuning_token1 = 77, + aux_sym_variable_tuning_token2 = 78, + aux_sym_variable_tuning_token3 = 79, + aux_sym_variable_tuning_token4 = 80, + aux_sym_variable_tuning_token5 = 81, + aux_sym_variable_tuning_token6 = 82, + aux_sym_scope_tuning_token1 = 83, + aux_sym_scope_tuning_token2 = 84, + aux_sym_scope_tuning_token3 = 85, + aux_sym_scope_tuning_token4 = 86, + aux_sym_access_tuning_token1 = 87, + aux_sym_access_tuning_token2 = 88, + aux_sym_access_tuning_token3 = 89, + aux_sym_serialization_tuning_token1 = 90, + aux_sym_serialization_tuning_token2 = 91, + aux_sym_variable_definition_token1 = 92, + aux_sym_variable_definition_token2 = 93, + aux_sym_variable_definition_token3 = 94, + aux_sym_variable_definition_token4 = 95, + aux_sym_variable_definition_token5 = 96, + aux_sym_variable_definition_token6 = 97, + aux_sym_buffer_definition_token1 = 98, + aux_sym_buffer_definition_token2 = 99, + aux_sym_buffer_definition_token3 = 100, + aux_sym_query_definition_tuning_token1 = 101, + anon_sym_SCROLLING = 102, + aux_sym_query_definition_tuning_token2 = 103, + aux_sym_query_definition_token1 = 104, + aux_sym_query_definition_token2 = 105, + aux_sym_query_definition_token3 = 106, + anon_sym_COMMA = 107, + aux_sym_argument_mode_token1 = 108, + aux_sym_argument_mode_token2 = 109, + aux_sym_if_statement_token1 = 110, + aux_sym_if_statement_token2 = 111, + aux_sym_else_if_statement_token1 = 112, + anon_sym_COLON = 113, + aux_sym__while_condition_token1 = 114, + aux_sym_repeat_statement_token1 = 115, + aux_sym_do_while_statement_token1 = 116, aux_sym__procedure_terminator_token1 = 117, aux_sym_procedure_parameter_definition_token1 = 118, aux_sym_procedure_parameter_definition_token2 = 119, aux_sym__function_terminator_token1 = 120, - aux_sym_function_statement_token1 = 121, - aux_sym_class_statement_token1 = 122, - aux_sym_class_statement_token2 = 123, - aux_sym_implements_token1 = 124, - aux_sym_use_widget_pool_token1 = 125, - aux_sym_abstract_token1 = 126, - aux_sym_final_token1 = 127, - anon_sym_NO_DASHERROR = 128, - aux_sym_object_access_token1 = 129, - aux_sym_stream_definition_token1 = 130, - aux_sym_input_close_statement_token1 = 131, - aux_sym_input_close_statement_token2 = 132, - aux_sym_input_stream_statement_token1 = 133, - aux_sym_on_error_phrase_token1 = 134, - aux_sym_on_error_phrase_token2 = 135, - aux_sym_on_error_phrase_token3 = 136, - aux_sym_on_error_phrase_token4 = 137, - aux_sym_on_error_phrase_token5 = 138, - aux_sym_on_error_phrase_token6 = 139, - aux_sym_on_error_phrase_token7 = 140, - aux_sym_on_error_phrase_token8 = 141, - aux_sym_on_stop_phrase_token1 = 142, - aux_sym_on_quit_phrase_token1 = 143, - aux_sym__case_terminator_token1 = 144, - aux_sym_case_when_branch_token1 = 145, - aux_sym_case_otherwise_branch_token1 = 146, - aux_sym_where_clause_token1 = 147, - aux_sym_query_tuning_token1 = 148, - aux_sym_query_tuning_token2 = 149, - aux_sym_query_tuning_token3 = 150, - aux_sym_query_tuning_token4 = 151, - aux_sym_query_tuning_token5 = 152, - aux_sym_query_tuning_token6 = 153, - aux_sym_sort_order_token1 = 154, - aux_sym_sort_order_token2 = 155, - aux_sym_sort_order_token3 = 156, - aux_sym_sort_order_token4 = 157, - aux_sym_sort_clause_token1 = 158, - aux_sym_sort_clause_token2 = 159, - aux_sym_for_phrase_token1 = 160, - aux_sym_for_phrase_token2 = 161, - aux_sym_for_phrase_token3 = 162, - aux_sym__find_type_token1 = 163, - aux_sym__find_type_token2 = 164, - aux_sym_find_statement_token1 = 165, - aux_sym_can_find_expression_token1 = 166, - aux_sym_of_token1 = 167, - aux_sym__using_first_token1 = 168, - aux_sym__using_and_token1 = 169, - aux_sym_transaction_statement_token1 = 170, - aux_sym_assign_statement_token1 = 171, - aux_sym_catch_statement_token1 = 172, - aux_sym_finally_statement_token1 = 173, - aux_sym_accumulate_aggregate_token1 = 174, - aux_sym_accumulate_aggregate_token2 = 175, - aux_sym_accumulate_aggregate_token3 = 176, - aux_sym_accumulate_aggregate_token4 = 177, - aux_sym_accumulate_aggregate_token5 = 178, - aux_sym_accumulate_aggregate_token6 = 179, - aux_sym_accumulate_aggregate_token7 = 180, - aux_sym_accumulate_aggregate_token8 = 181, - aux_sym_accumulate_aggregate_token9 = 182, - aux_sym_accumulate_aggregate_token10 = 183, - aux_sym_accumulate_statement_token1 = 184, - anon_sym_ = 185, - aux_sym_accumulate_expression_token1 = 186, - aux_sym_available_expression_token1 = 187, - aux_sym_available_expression_token2 = 188, - anon_sym_ROUTINE_DASHLEVEL = 189, - anon_sym_BLOCK_DASHLEVEL = 190, - aux_sym_temp_table_tuning_token1 = 191, - anon_sym_LIKE = 192, - aux_sym_field_option_token1 = 193, - aux_sym_field_definition_token1 = 194, - aux_sym_index_tuning_token1 = 195, - aux_sym_index_tuning_token2 = 196, - aux_sym_index_tuning_token3 = 197, - aux_sym_index_tuning_token4 = 198, - aux_sym_index_definition_token1 = 199, - aux_sym_widget_field_token1 = 200, - aux_sym_on_statement_token1 = 201, - sym__namedot = 202, - sym_source_code = 203, - sym_body = 204, - sym_comment = 205, - sym_constant = 206, - sym_qualified_name = 207, - sym__block_terminator = 208, - sym_boolean_literal = 209, - sym__decimal_literal = 210, - sym_number_literal = 211, - sym__string_literal = 212, - sym_double_quoted_string = 213, - sym_single_quoted_string = 214, - sym_parenthesized_expression = 215, - sym__logical_operator = 216, - sym_logical_expression = 217, - sym__unary_minus_expressions = 218, - sym_unary_expression = 219, - sym_ambiguous_expression = 220, - sym_current_changed_expression = 221, - sym_locked_expression = 222, - sym_input_expression = 223, - sym__additive_operator = 224, - sym_additive_expression = 225, - sym__multiplicative_operator = 226, - sym_multiplicative_expression = 227, - sym__comparison_operator = 228, - sym_comparison_expression = 229, - sym__binary_expression = 230, - sym__terminated_statement = 231, - sym_include_argument = 232, - sym_include = 233, - sym_primitive_type = 234, - sym_assignment = 235, - sym_variable_tuning = 236, - sym_scope_tuning = 237, - sym_access_tuning = 238, - sym_serialization_tuning = 239, - sym_variable_definition = 240, - sym_variable_assignment = 241, - sym_buffer_definition = 242, - sym_query_definition_tuning = 243, - sym_query_fields = 244, - sym_query_definition = 245, - sym_function_call_statement = 246, - sym__function_call_arguments = 247, - sym_argument_mode = 248, - sym__function_argument_with_mode = 249, - sym_function_call_argument = 250, - sym_function_call = 251, - sym_if_statement = 252, - sym__if_do_variant = 253, - sym__if_then_variant = 254, - sym_else_if_statement = 255, - sym_else_statement = 256, - sym_ternary_expression = 257, - sym_label = 258, - sym__loop_statement = 259, - sym__while_condition = 260, - sym_repeat_statement = 261, - sym_do_while_statement = 262, - sym_do_statement = 263, - sym__procedure_terminator = 264, - sym_procedure_statement = 265, - sym_procedure_parameter_definition = 266, - sym__function_terminator = 267, - sym_function_parameter_mode = 268, - sym_function_parameter = 269, - sym_function_statement = 270, - sym_return_statement = 271, - sym_class_statement = 272, - sym_implements = 273, - sym_use_widget_pool = 274, - sym_abstract = 275, - sym_final = 276, - sym_serializable = 277, - sym_new_expression = 278, - sym_object_access = 279, - sym_stream_definition = 280, - sym_input_close_statement = 281, - sym_output_close_statement = 282, - sym__stream_statement = 283, - sym_input_stream_statement = 284, - sym_output_stream_statement = 285, - sym_on_error_phrase = 286, - sym_on_stop_phrase = 287, - sym_on_quit_phrase = 288, - sym_do_block = 289, - sym__case_terminator = 290, - sym__case_branch_body = 291, - sym_case_when_branch = 292, - sym_case_otherwise_branch = 293, - sym_case_body = 294, - sym_case_statement = 295, - sym_where_clause = 296, - sym__pre_tuning = 297, - sym_query_tuning = 298, - sym_sort_order = 299, - sym_sort_column = 300, - sym_sort_clause = 301, - sym_for_phrase = 302, - sym_for_statement = 303, - sym__find_type = 304, - sym_find_statement = 305, - sym_can_find_expression = 306, - sym_of = 307, - sym__using_first = 308, - sym__using_and = 309, - sym_transaction_statement = 310, - sym_abl_statement = 311, - sym_assign_statement = 312, - sym_catch_statement = 313, - sym_finally_statement = 314, - sym_accumulate_aggregate = 315, - sym_accumulate_statement = 316, - sym_accumulate_expression = 317, - sym_available_expression = 318, - sym_undo_statement = 319, - sym_error_scope_statement = 320, - sym_temp_table_tuning = 321, - sym_field_option = 322, - sym_field_definition = 323, - sym_index_tuning = 324, - sym_index_definition = 325, - sym_temp_table_definition = 326, - sym_widget_field = 327, - sym_widget_phrase = 328, - sym_on_statement = 329, - sym__expression = 330, - sym__statement = 331, - aux_sym_source_code_repeat1 = 332, - aux_sym_qualified_name_repeat1 = 333, - aux_sym_double_quoted_string_repeat1 = 334, - aux_sym_single_quoted_string_repeat1 = 335, - aux_sym_include_repeat1 = 336, - aux_sym_variable_definition_repeat1 = 337, - aux_sym_variable_definition_repeat2 = 338, - aux_sym_buffer_definition_repeat1 = 339, - aux_sym_query_fields_repeat1 = 340, - aux_sym_query_definition_repeat1 = 341, - aux_sym__function_call_arguments_repeat1 = 342, - aux_sym_if_statement_repeat1 = 343, - aux_sym_function_statement_repeat1 = 344, - aux_sym_class_statement_repeat1 = 345, - aux_sym_implements_repeat1 = 346, - aux_sym_object_access_repeat1 = 347, - aux_sym_case_body_repeat1 = 348, - aux_sym_sort_clause_repeat1 = 349, - aux_sym_for_phrase_repeat1 = 350, - aux_sym_for_phrase_repeat2 = 351, - aux_sym_for_statement_repeat1 = 352, - aux_sym_can_find_expression_repeat1 = 353, - aux_sym_can_find_expression_repeat2 = 354, - aux_sym_abl_statement_repeat1 = 355, - aux_sym_assign_statement_repeat1 = 356, - aux_sym_accumulate_statement_repeat1 = 357, - aux_sym_field_definition_repeat1 = 358, - aux_sym_index_definition_repeat1 = 359, - aux_sym_temp_table_definition_repeat1 = 360, - aux_sym_temp_table_definition_repeat2 = 361, - aux_sym_widget_phrase_repeat1 = 362, - aux_sym_on_statement_repeat1 = 363, - aux_sym_on_statement_repeat2 = 364, + aux_sym_function_parameter_token1 = 121, + aux_sym_function_parameter_token2 = 122, + aux_sym_function_statement_token1 = 123, + aux_sym_interface_statement_token1 = 124, + aux_sym_property_tuning_token1 = 125, + aux_sym_property_tuning_token2 = 126, + aux_sym_getter_token1 = 127, + aux_sym_setter_token1 = 128, + aux_sym_property_definition_token1 = 129, + aux_sym_property_definition_token2 = 130, + aux_sym_event_definition_token1 = 131, + aux_sym_event_definition_token2 = 132, + aux_sym_method_definition_token1 = 133, + aux_sym_data_relation_token1 = 134, + aux_sym_data_relation_token2 = 135, + aux_sym_class_statement_token1 = 136, + aux_sym_inherits_token1 = 137, + aux_sym_implements_token1 = 138, + aux_sym_use_widget_pool_token1 = 139, + aux_sym_final_token1 = 140, + anon_sym_NO_DASHERROR = 141, + aux_sym_object_access_token1 = 142, + aux_sym_stream_definition_token1 = 143, + aux_sym_input_close_statement_token1 = 144, + aux_sym_input_close_statement_token2 = 145, + aux_sym_input_stream_statement_token1 = 146, + aux_sym_output_stream_statement_token1 = 147, + aux_sym_on_error_phrase_token1 = 148, + aux_sym_on_error_phrase_token2 = 149, + aux_sym_on_error_phrase_token3 = 150, + aux_sym_on_error_phrase_token4 = 151, + aux_sym_on_error_phrase_token5 = 152, + aux_sym_on_error_phrase_token6 = 153, + aux_sym_on_error_phrase_token7 = 154, + aux_sym_on_error_phrase_token8 = 155, + aux_sym_on_stop_phrase_token1 = 156, + aux_sym_on_quit_phrase_token1 = 157, + aux_sym_stop_after_phrase_token1 = 158, + aux_sym_do_tuning_token1 = 159, + anon_sym_BY = 160, + aux_sym__case_terminator_token1 = 161, + aux_sym_case_when_branch_token1 = 162, + aux_sym_case_otherwise_branch_token1 = 163, + aux_sym_where_clause_token1 = 164, + aux_sym_query_tuning_token1 = 165, + aux_sym_query_tuning_token2 = 166, + aux_sym_query_tuning_token3 = 167, + aux_sym_query_tuning_token4 = 168, + aux_sym_query_tuning_token5 = 169, + aux_sym_query_tuning_token6 = 170, + aux_sym_sort_order_token1 = 171, + aux_sym_sort_order_token2 = 172, + aux_sym_sort_order_token3 = 173, + aux_sym_sort_order_token4 = 174, + aux_sym_sort_clause_token1 = 175, + aux_sym_sort_clause_token2 = 176, + aux_sym_for_phrase_token1 = 177, + aux_sym_for_phrase_token2 = 178, + aux_sym_for_phrase_token3 = 179, + aux_sym__find_type_token1 = 180, + aux_sym__find_type_token2 = 181, + aux_sym_find_statement_token1 = 182, + aux_sym_can_find_expression_token1 = 183, + aux_sym_of_token1 = 184, + aux_sym__using_first_token1 = 185, + aux_sym__using_and_token1 = 186, + aux_sym_assign_statement_token1 = 187, + aux_sym_catch_statement_token1 = 188, + aux_sym_finally_statement_token1 = 189, + aux_sym_accumulate_aggregate_token1 = 190, + aux_sym_accumulate_aggregate_token2 = 191, + aux_sym_accumulate_aggregate_token3 = 192, + aux_sym_accumulate_aggregate_token4 = 193, + aux_sym_accumulate_aggregate_token5 = 194, + aux_sym_accumulate_aggregate_token6 = 195, + aux_sym_accumulate_aggregate_token7 = 196, + aux_sym_accumulate_aggregate_token8 = 197, + aux_sym_accumulate_aggregate_token9 = 198, + aux_sym_accumulate_aggregate_token10 = 199, + aux_sym_accumulate_statement_token1 = 200, + anon_sym_ = 201, + aux_sym_accumulate_expression_token1 = 202, + aux_sym_available_expression_token1 = 203, + aux_sym_available_expression_token2 = 204, + anon_sym_ROUTINE_DASHLEVEL = 205, + anon_sym_BLOCK_DASHLEVEL = 206, + aux_sym_temp_table_tuning_token1 = 207, + anon_sym_LIKE = 208, + aux_sym_field_definition_token1 = 209, + aux_sym_index_tuning_token1 = 210, + aux_sym_index_tuning_token2 = 211, + aux_sym_index_tuning_token3 = 212, + aux_sym_index_tuning_token4 = 213, + aux_sym_index_definition_token1 = 214, + aux_sym_widget_field_token1 = 215, + aux_sym_on_statement_token1 = 216, + sym__namedot = 217, + sym_source_code = 218, + sym_body = 219, + sym_comment = 220, + sym_constant = 221, + sym_qualified_name = 222, + sym__block_terminator = 223, + sym_boolean_literal = 224, + sym__decimal_literal = 225, + sym_number_literal = 226, + sym__string_literal = 227, + sym_double_quoted_string = 228, + sym_single_quoted_string = 229, + sym_parenthesized_expression = 230, + sym__logical_operator = 231, + sym_logical_expression = 232, + sym__unary_minus_expressions = 233, + sym_unary_expression = 234, + sym_ambiguous_expression = 235, + sym_current_changed_expression = 236, + sym_locked_expression = 237, + sym_input_expression = 238, + sym__additive_operator = 239, + sym_additive_expression = 240, + sym__multiplicative_operator = 241, + sym_multiplicative_expression = 242, + sym__comparison_operator = 243, + sym_comparison_expression = 244, + sym__binary_expression = 245, + sym__terminated_statement = 246, + sym_include_argument = 247, + sym_include = 248, + sym_primitive_type = 249, + sym_assignment = 250, + sym_variable_tuning = 251, + sym_scope_tuning = 252, + sym_access_tuning = 253, + sym_serialization_tuning = 254, + sym_variable_definition = 255, + sym_variable_assignment = 256, + sym_buffer_definition = 257, + sym_query_definition_tuning = 258, + sym_query_fields = 259, + sym_query_definition = 260, + sym_function_call_statement = 261, + sym__function_call_arguments = 262, + sym_argument_mode = 263, + sym__function_argument_with_mode = 264, + sym_function_call_argument = 265, + sym_function_call = 266, + sym_if_statement = 267, + sym__if_do_variant = 268, + sym__if_then_variant = 269, + sym_else_if_statement = 270, + sym_else_statement = 271, + sym_ternary_expression = 272, + sym_label = 273, + sym__loop_statement = 274, + sym__while_condition = 275, + sym_repeat_statement = 276, + sym_do_while_statement = 277, + sym__procedure_terminator = 278, + sym_procedure_statement = 279, + sym_procedure_parameter_definition = 280, + sym__function_terminator = 281, + sym_function_parameter_mode = 282, + sym_function_parameter = 283, + sym_function_statement = 284, + sym_return_statement = 285, + sym_interface_body = 286, + sym_interface_statement = 287, + sym_property_tuning = 288, + sym_getter = 289, + sym_setter = 290, + sym_property_definition = 291, + sym_event_definition = 292, + sym_method_definition = 293, + sym_data_relation = 294, + sym_dataset_definition = 295, + sym_class_statement = 296, + sym_inherits = 297, + sym_implements = 298, + sym_use_widget_pool = 299, + sym_abstract = 300, + sym_final = 301, + sym_serializable = 302, + sym_new_expression = 303, + sym_object_access = 304, + sym_stream_definition = 305, + sym_input_close_statement = 306, + sym_output_close_statement = 307, + sym__stream_statement = 308, + sym_input_stream_statement = 309, + sym_output_stream_statement = 310, + sym_on_error_phrase = 311, + sym_on_stop_phrase = 312, + sym_on_quit_phrase = 313, + sym_stop_after_phrase = 314, + sym_do_tuning = 315, + sym_to_phrase = 316, + sym_do_block = 317, + sym__case_terminator = 318, + sym__case_branch_body = 319, + sym_case_when_branch = 320, + sym_case_otherwise_branch = 321, + sym_case_body = 322, + sym_case_statement = 323, + sym_where_clause = 324, + sym__pre_tuning = 325, + sym_query_tuning = 326, + sym_sort_order = 327, + sym_sort_column = 328, + sym_sort_clause = 329, + sym_for_phrase = 330, + sym_for_statement = 331, + sym__find_type = 332, + sym_find_statement = 333, + sym_can_find_expression = 334, + sym_of = 335, + sym__using_first = 336, + sym__using_and = 337, + sym_abl_statement = 338, + sym_assign_statement = 339, + sym_catch_statement = 340, + sym_finally_statement = 341, + sym_accumulate_aggregate = 342, + sym_accumulate_statement = 343, + sym_accumulate_expression = 344, + sym_available_expression = 345, + sym_undo_statement = 346, + sym_error_scope_statement = 347, + sym_temp_table_tuning = 348, + sym_field_option = 349, + sym_field_definition = 350, + sym_index_tuning = 351, + sym_index_definition = 352, + sym_temp_table_definition = 353, + sym_widget_field = 354, + sym_widget_phrase = 355, + sym_on_statement = 356, + sym__expression = 357, + sym__statement = 358, + aux_sym_source_code_repeat1 = 359, + aux_sym_qualified_name_repeat1 = 360, + aux_sym_double_quoted_string_repeat1 = 361, + aux_sym_single_quoted_string_repeat1 = 362, + aux_sym_include_repeat1 = 363, + aux_sym_variable_definition_repeat1 = 364, + aux_sym_variable_definition_repeat2 = 365, + aux_sym_buffer_definition_repeat1 = 366, + aux_sym_query_fields_repeat1 = 367, + aux_sym_query_definition_repeat1 = 368, + aux_sym__function_call_arguments_repeat1 = 369, + aux_sym_if_statement_repeat1 = 370, + aux_sym_function_statement_repeat1 = 371, + aux_sym_interface_body_repeat1 = 372, + aux_sym_property_definition_repeat1 = 373, + aux_sym_property_definition_repeat2 = 374, + aux_sym_data_relation_repeat1 = 375, + aux_sym_class_statement_repeat1 = 376, + aux_sym_inherits_repeat1 = 377, + aux_sym_object_access_repeat1 = 378, + aux_sym_do_block_repeat1 = 379, + aux_sym_case_body_repeat1 = 380, + aux_sym_sort_clause_repeat1 = 381, + aux_sym_for_phrase_repeat1 = 382, + aux_sym_for_phrase_repeat2 = 383, + aux_sym_for_statement_repeat1 = 384, + aux_sym_can_find_expression_repeat1 = 385, + aux_sym_can_find_expression_repeat2 = 386, + aux_sym_abl_statement_repeat1 = 387, + aux_sym_assign_statement_repeat1 = 388, + aux_sym_accumulate_statement_repeat1 = 389, + aux_sym_field_definition_repeat1 = 390, + aux_sym_index_definition_repeat1 = 391, + aux_sym_temp_table_definition_repeat1 = 392, + aux_sym_temp_table_definition_repeat2 = 393, + aux_sym_widget_phrase_repeat1 = 394, + aux_sym_on_statement_repeat1 = 395, + aux_sym_on_statement_repeat2 = 396, }; static const char * const ts_symbol_names[] = { @@ -451,23 +483,24 @@ static const char * const ts_symbol_names[] = { [aux_sym__comparison_operator_token8] = "MATCHES", [aux_sym__comparison_operator_token9] = "CONTAINS", [aux_sym_include_argument_token1] = "include_argument_token1", - [aux_sym_primitive_type_token1] = "LOGICAL", - [aux_sym_primitive_type_token2] = "INTEGER", - [aux_sym_primitive_type_token3] = "INT", - [aux_sym_primitive_type_token4] = "CHARACTER", - [aux_sym_primitive_type_token5] = "CHAR", - [aux_sym_primitive_type_token6] = "DECIMAL", - [aux_sym_primitive_type_token7] = "DATE", - [aux_sym_primitive_type_token8] = "DATETIME", - [aux_sym_primitive_type_token9] = "DATETIME-TZ", - [aux_sym_primitive_type_token10] = "INT64", - [aux_sym_primitive_type_token11] = "LONGCHAR", - [aux_sym_primitive_type_token12] = "MEMPTR", - [aux_sym_primitive_type_token13] = "RAW", - [aux_sym_primitive_type_token14] = "RECID", - [aux_sym_primitive_type_token15] = "ROWID", - [aux_sym_primitive_type_token16] = "HANDLE", - [aux_sym_primitive_type_token17] = "COM-HANDLE", + [aux_sym_primitive_type_token1] = "VOID", + [aux_sym_primitive_type_token2] = "LOGICAL", + [aux_sym_primitive_type_token3] = "INTEGER", + [aux_sym_primitive_type_token4] = "INT", + [aux_sym_primitive_type_token5] = "CHARACTER", + [aux_sym_primitive_type_token6] = "CHAR", + [aux_sym_primitive_type_token7] = "DECIMAL", + [aux_sym_primitive_type_token8] = "DATE", + [aux_sym_primitive_type_token9] = "DATETIME", + [aux_sym_primitive_type_token10] = "DATETIME-TZ", + [aux_sym_primitive_type_token11] = "INT64", + [aux_sym_primitive_type_token12] = "LONGCHAR", + [aux_sym_primitive_type_token13] = "MEMPTR", + [aux_sym_primitive_type_token14] = "RAW", + [aux_sym_primitive_type_token15] = "RECID", + [aux_sym_primitive_type_token16] = "ROWID", + [aux_sym_primitive_type_token17] = "HANDLE", + [aux_sym_primitive_type_token18] = "COM-HANDLE", [aux_sym_variable_tuning_token1] = "INITIAL", [aux_sym_variable_tuning_token2] = "FORMAT", [aux_sym_variable_tuning_token3] = "LABEL", @@ -508,17 +541,29 @@ static const char * const ts_symbol_names[] = { [aux_sym__while_condition_token1] = "WHILE", [aux_sym_repeat_statement_token1] = "REPEAT", [aux_sym_do_while_statement_token1] = "DO", - [aux_sym_do_statement_token1] = "TO", [aux_sym__procedure_terminator_token1] = "PROCEDURE", [aux_sym_procedure_parameter_definition_token1] = "RETURN", [aux_sym_procedure_parameter_definition_token2] = "PARAMETER", [aux_sym__function_terminator_token1] = "FUNCTION", + [aux_sym_function_parameter_token1] = "DATASET", + [aux_sym_function_parameter_token2] = "BIND", [aux_sym_function_statement_token1] = "RETURNS", + [aux_sym_interface_statement_token1] = "INTERFACE", + [aux_sym_property_tuning_token1] = "ABSTRACT", + [aux_sym_property_tuning_token2] = "OVERRIDE", + [aux_sym_getter_token1] = "GET", + [aux_sym_setter_token1] = "SET", + [aux_sym_property_definition_token1] = "PROPERTY", + [aux_sym_property_definition_token2] = "EXTENT", + [aux_sym_event_definition_token1] = "EVENT", + [aux_sym_event_definition_token2] = "SIGNATURE", + [aux_sym_method_definition_token1] = "METHOD", + [aux_sym_data_relation_token1] = "DATA-RELATION", + [aux_sym_data_relation_token2] = "RELATION-FIELDS", [aux_sym_class_statement_token1] = "CLASS", - [aux_sym_class_statement_token2] = "INHERITS", + [aux_sym_inherits_token1] = "INHERITS", [aux_sym_implements_token1] = "IMPLEMENTS", [aux_sym_use_widget_pool_token1] = "USE-WIDGET-POOL", - [aux_sym_abstract_token1] = "ABSTRACT", [aux_sym_final_token1] = "FINAL", [anon_sym_NO_DASHERROR] = "NO-ERROR", [aux_sym_object_access_token1] = "object_access_token1", @@ -526,6 +571,7 @@ static const char * const ts_symbol_names[] = { [aux_sym_input_close_statement_token1] = "STREAM-HANDLE", [aux_sym_input_close_statement_token2] = "CLOSE", [aux_sym_input_stream_statement_token1] = "FROM", + [aux_sym_output_stream_statement_token1] = "TO", [aux_sym_on_error_phrase_token1] = "ON", [aux_sym_on_error_phrase_token2] = "ERROR", [aux_sym_on_error_phrase_token3] = "UNDO", @@ -536,6 +582,9 @@ static const char * const ts_symbol_names[] = { [aux_sym_on_error_phrase_token8] = "THROW", [aux_sym_on_stop_phrase_token1] = "STOP", [aux_sym_on_quit_phrase_token1] = "QUIT", + [aux_sym_stop_after_phrase_token1] = "STOP-AFTER", + [aux_sym_do_tuning_token1] = "TRANSACTION", + [anon_sym_BY] = "BY", [aux_sym__case_terminator_token1] = "CASE", [aux_sym_case_when_branch_token1] = "WHEN", [aux_sym_case_otherwise_branch_token1] = "OTHERWISE", @@ -562,7 +611,6 @@ static const char * const ts_symbol_names[] = { [aux_sym_of_token1] = "OF", [aux_sym__using_first_token1] = "USING", [aux_sym__using_and_token1] = "AND", - [aux_sym_transaction_statement_token1] = "TRANSACTION", [aux_sym_assign_statement_token1] = "ASSIGN", [aux_sym_catch_statement_token1] = "CATCH", [aux_sym_finally_statement_token1] = "FINALLY", @@ -585,7 +633,6 @@ static const char * const ts_symbol_names[] = { [anon_sym_BLOCK_DASHLEVEL] = "BLOCK-LEVEL", [aux_sym_temp_table_tuning_token1] = "REFERENCE-ONLY", [anon_sym_LIKE] = "LIKE", - [aux_sym_field_option_token1] = "EXTENT", [aux_sym_field_definition_token1] = "FIELD", [aux_sym_index_tuning_token1] = "IS", [aux_sym_index_tuning_token2] = "PRIMARY", @@ -655,7 +702,6 @@ static const char * const ts_symbol_names[] = { [sym__while_condition] = "_while_condition", [sym_repeat_statement] = "repeat_statement", [sym_do_while_statement] = "do_while_statement", - [sym_do_statement] = "do_statement", [sym__procedure_terminator] = "_procedure_terminator", [sym_procedure_statement] = "procedure_statement", [sym_procedure_parameter_definition] = "procedure_parameter_definition", @@ -664,7 +710,18 @@ static const char * const ts_symbol_names[] = { [sym_function_parameter] = "function_parameter", [sym_function_statement] = "function_statement", [sym_return_statement] = "return_statement", + [sym_interface_body] = "interface_body", + [sym_interface_statement] = "interface_statement", + [sym_property_tuning] = "property_tuning", + [sym_getter] = "getter", + [sym_setter] = "setter", + [sym_property_definition] = "property_definition", + [sym_event_definition] = "event_definition", + [sym_method_definition] = "method_definition", + [sym_data_relation] = "data_relation", + [sym_dataset_definition] = "dataset_definition", [sym_class_statement] = "class_statement", + [sym_inherits] = "inherits", [sym_implements] = "implements", [sym_use_widget_pool] = "use_widget_pool", [sym_abstract] = "abstract", @@ -681,6 +738,9 @@ static const char * const ts_symbol_names[] = { [sym_on_error_phrase] = "on_error_phrase", [sym_on_stop_phrase] = "on_stop_phrase", [sym_on_quit_phrase] = "on_quit_phrase", + [sym_stop_after_phrase] = "stop_after_phrase", + [sym_do_tuning] = "do_tuning", + [sym_to_phrase] = "to_phrase", [sym_do_block] = "do_block", [sym__case_terminator] = "_case_terminator", [sym__case_branch_body] = "_case_branch_body", @@ -702,7 +762,6 @@ static const char * const ts_symbol_names[] = { [sym_of] = "of", [sym__using_first] = "using", [sym__using_and] = "using", - [sym_transaction_statement] = "transaction_statement", [sym_abl_statement] = "abl_statement", [sym_assign_statement] = "assign_statement", [sym_catch_statement] = "catch_statement", @@ -737,9 +796,14 @@ static const char * const ts_symbol_names[] = { [aux_sym__function_call_arguments_repeat1] = "_function_call_arguments_repeat1", [aux_sym_if_statement_repeat1] = "if_statement_repeat1", [aux_sym_function_statement_repeat1] = "function_statement_repeat1", + [aux_sym_interface_body_repeat1] = "interface_body_repeat1", + [aux_sym_property_definition_repeat1] = "property_definition_repeat1", + [aux_sym_property_definition_repeat2] = "property_definition_repeat2", + [aux_sym_data_relation_repeat1] = "data_relation_repeat1", [aux_sym_class_statement_repeat1] = "class_statement_repeat1", - [aux_sym_implements_repeat1] = "implements_repeat1", + [aux_sym_inherits_repeat1] = "inherits_repeat1", [aux_sym_object_access_repeat1] = "object_access_repeat1", + [aux_sym_do_block_repeat1] = "do_block_repeat1", [aux_sym_case_body_repeat1] = "case_body_repeat1", [aux_sym_sort_clause_repeat1] = "sort_clause_repeat1", [aux_sym_for_phrase_repeat1] = "for_phrase_repeat1", @@ -836,6 +900,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_primitive_type_token15] = aux_sym_primitive_type_token15, [aux_sym_primitive_type_token16] = aux_sym_primitive_type_token16, [aux_sym_primitive_type_token17] = aux_sym_primitive_type_token17, + [aux_sym_primitive_type_token18] = aux_sym_primitive_type_token18, [aux_sym_variable_tuning_token1] = aux_sym_variable_tuning_token1, [aux_sym_variable_tuning_token2] = aux_sym_variable_tuning_token2, [aux_sym_variable_tuning_token3] = aux_sym_variable_tuning_token3, @@ -876,17 +941,29 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym__while_condition_token1] = aux_sym__while_condition_token1, [aux_sym_repeat_statement_token1] = aux_sym_repeat_statement_token1, [aux_sym_do_while_statement_token1] = aux_sym_do_while_statement_token1, - [aux_sym_do_statement_token1] = aux_sym_do_statement_token1, [aux_sym__procedure_terminator_token1] = aux_sym__procedure_terminator_token1, [aux_sym_procedure_parameter_definition_token1] = aux_sym_procedure_parameter_definition_token1, [aux_sym_procedure_parameter_definition_token2] = aux_sym_procedure_parameter_definition_token2, [aux_sym__function_terminator_token1] = aux_sym__function_terminator_token1, + [aux_sym_function_parameter_token1] = aux_sym_function_parameter_token1, + [aux_sym_function_parameter_token2] = aux_sym_function_parameter_token2, [aux_sym_function_statement_token1] = aux_sym_function_statement_token1, + [aux_sym_interface_statement_token1] = aux_sym_interface_statement_token1, + [aux_sym_property_tuning_token1] = aux_sym_property_tuning_token1, + [aux_sym_property_tuning_token2] = aux_sym_property_tuning_token2, + [aux_sym_getter_token1] = aux_sym_getter_token1, + [aux_sym_setter_token1] = aux_sym_setter_token1, + [aux_sym_property_definition_token1] = aux_sym_property_definition_token1, + [aux_sym_property_definition_token2] = aux_sym_property_definition_token2, + [aux_sym_event_definition_token1] = aux_sym_event_definition_token1, + [aux_sym_event_definition_token2] = aux_sym_event_definition_token2, + [aux_sym_method_definition_token1] = aux_sym_method_definition_token1, + [aux_sym_data_relation_token1] = aux_sym_data_relation_token1, + [aux_sym_data_relation_token2] = aux_sym_data_relation_token2, [aux_sym_class_statement_token1] = aux_sym_class_statement_token1, - [aux_sym_class_statement_token2] = aux_sym_class_statement_token2, + [aux_sym_inherits_token1] = aux_sym_inherits_token1, [aux_sym_implements_token1] = aux_sym_implements_token1, [aux_sym_use_widget_pool_token1] = aux_sym_use_widget_pool_token1, - [aux_sym_abstract_token1] = aux_sym_abstract_token1, [aux_sym_final_token1] = aux_sym_final_token1, [anon_sym_NO_DASHERROR] = anon_sym_NO_DASHERROR, [aux_sym_object_access_token1] = aux_sym_object_access_token1, @@ -894,6 +971,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_input_close_statement_token1] = aux_sym_input_close_statement_token1, [aux_sym_input_close_statement_token2] = aux_sym_input_close_statement_token2, [aux_sym_input_stream_statement_token1] = aux_sym_input_stream_statement_token1, + [aux_sym_output_stream_statement_token1] = aux_sym_output_stream_statement_token1, [aux_sym_on_error_phrase_token1] = aux_sym_on_error_phrase_token1, [aux_sym_on_error_phrase_token2] = aux_sym_on_error_phrase_token2, [aux_sym_on_error_phrase_token3] = aux_sym_on_error_phrase_token3, @@ -904,6 +982,9 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_on_error_phrase_token8] = aux_sym_on_error_phrase_token8, [aux_sym_on_stop_phrase_token1] = aux_sym_on_stop_phrase_token1, [aux_sym_on_quit_phrase_token1] = aux_sym_on_quit_phrase_token1, + [aux_sym_stop_after_phrase_token1] = aux_sym_stop_after_phrase_token1, + [aux_sym_do_tuning_token1] = aux_sym_do_tuning_token1, + [anon_sym_BY] = anon_sym_BY, [aux_sym__case_terminator_token1] = aux_sym__case_terminator_token1, [aux_sym_case_when_branch_token1] = aux_sym_case_when_branch_token1, [aux_sym_case_otherwise_branch_token1] = aux_sym_case_otherwise_branch_token1, @@ -919,7 +1000,7 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_sort_order_token3] = aux_sym_sort_order_token3, [aux_sym_sort_order_token4] = aux_sym_sort_order_token4, [aux_sym_sort_clause_token1] = aux_sym_sort_clause_token1, - [aux_sym_sort_clause_token2] = aux_sym_sort_clause_token2, + [aux_sym_sort_clause_token2] = anon_sym_BY, [aux_sym_for_phrase_token1] = aux_sym_for_phrase_token1, [aux_sym_for_phrase_token2] = aux_sym_for_phrase_token2, [aux_sym_for_phrase_token3] = aux_sym_for_phrase_token3, @@ -930,7 +1011,6 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym_of_token1] = aux_sym_of_token1, [aux_sym__using_first_token1] = aux_sym__using_first_token1, [aux_sym__using_and_token1] = aux_sym__using_and_token1, - [aux_sym_transaction_statement_token1] = aux_sym_transaction_statement_token1, [aux_sym_assign_statement_token1] = aux_sym_assign_statement_token1, [aux_sym_catch_statement_token1] = aux_sym_catch_statement_token1, [aux_sym_finally_statement_token1] = aux_sym_finally_statement_token1, @@ -953,7 +1033,6 @@ static const TSSymbol ts_symbol_map[] = { [anon_sym_BLOCK_DASHLEVEL] = anon_sym_BLOCK_DASHLEVEL, [aux_sym_temp_table_tuning_token1] = aux_sym_temp_table_tuning_token1, [anon_sym_LIKE] = anon_sym_LIKE, - [aux_sym_field_option_token1] = aux_sym_field_option_token1, [aux_sym_field_definition_token1] = aux_sym_field_definition_token1, [aux_sym_index_tuning_token1] = aux_sym_index_tuning_token1, [aux_sym_index_tuning_token2] = aux_sym_index_tuning_token2, @@ -1023,7 +1102,6 @@ static const TSSymbol ts_symbol_map[] = { [sym__while_condition] = sym__while_condition, [sym_repeat_statement] = sym_repeat_statement, [sym_do_while_statement] = sym_do_while_statement, - [sym_do_statement] = sym_do_statement, [sym__procedure_terminator] = sym__procedure_terminator, [sym_procedure_statement] = sym_procedure_statement, [sym_procedure_parameter_definition] = sym_procedure_parameter_definition, @@ -1032,7 +1110,18 @@ static const TSSymbol ts_symbol_map[] = { [sym_function_parameter] = sym_function_parameter, [sym_function_statement] = sym_function_statement, [sym_return_statement] = sym_return_statement, + [sym_interface_body] = sym_interface_body, + [sym_interface_statement] = sym_interface_statement, + [sym_property_tuning] = sym_property_tuning, + [sym_getter] = sym_getter, + [sym_setter] = sym_setter, + [sym_property_definition] = sym_property_definition, + [sym_event_definition] = sym_event_definition, + [sym_method_definition] = sym_method_definition, + [sym_data_relation] = sym_data_relation, + [sym_dataset_definition] = sym_dataset_definition, [sym_class_statement] = sym_class_statement, + [sym_inherits] = sym_inherits, [sym_implements] = sym_implements, [sym_use_widget_pool] = sym_use_widget_pool, [sym_abstract] = sym_abstract, @@ -1049,6 +1138,9 @@ static const TSSymbol ts_symbol_map[] = { [sym_on_error_phrase] = sym_on_error_phrase, [sym_on_stop_phrase] = sym_on_stop_phrase, [sym_on_quit_phrase] = sym_on_quit_phrase, + [sym_stop_after_phrase] = sym_stop_after_phrase, + [sym_do_tuning] = sym_do_tuning, + [sym_to_phrase] = sym_to_phrase, [sym_do_block] = sym_do_block, [sym__case_terminator] = sym__case_terminator, [sym__case_branch_body] = sym__case_branch_body, @@ -1070,7 +1162,6 @@ static const TSSymbol ts_symbol_map[] = { [sym_of] = sym_of, [sym__using_first] = sym__using_first, [sym__using_and] = sym__using_first, - [sym_transaction_statement] = sym_transaction_statement, [sym_abl_statement] = sym_abl_statement, [sym_assign_statement] = sym_assign_statement, [sym_catch_statement] = sym_catch_statement, @@ -1105,9 +1196,14 @@ static const TSSymbol ts_symbol_map[] = { [aux_sym__function_call_arguments_repeat1] = aux_sym__function_call_arguments_repeat1, [aux_sym_if_statement_repeat1] = aux_sym_if_statement_repeat1, [aux_sym_function_statement_repeat1] = aux_sym_function_statement_repeat1, + [aux_sym_interface_body_repeat1] = aux_sym_interface_body_repeat1, + [aux_sym_property_definition_repeat1] = aux_sym_property_definition_repeat1, + [aux_sym_property_definition_repeat2] = aux_sym_property_definition_repeat2, + [aux_sym_data_relation_repeat1] = aux_sym_data_relation_repeat1, [aux_sym_class_statement_repeat1] = aux_sym_class_statement_repeat1, - [aux_sym_implements_repeat1] = aux_sym_implements_repeat1, + [aux_sym_inherits_repeat1] = aux_sym_inherits_repeat1, [aux_sym_object_access_repeat1] = aux_sym_object_access_repeat1, + [aux_sym_do_block_repeat1] = aux_sym_do_block_repeat1, [aux_sym_case_body_repeat1] = aux_sym_case_body_repeat1, [aux_sym_sort_clause_repeat1] = aux_sym_sort_clause_repeat1, [aux_sym_for_phrase_repeat1] = aux_sym_for_phrase_repeat1, @@ -1432,6 +1528,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [aux_sym_primitive_type_token18] = { + .visible = true, + .named = false, + }, [aux_sym_variable_tuning_token1] = { .visible = true, .named = false, @@ -1592,10 +1692,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [aux_sym_do_statement_token1] = { - .visible = true, - .named = false, - }, [aux_sym__procedure_terminator_token1] = { .visible = true, .named = false, @@ -1612,27 +1708,79 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [aux_sym_function_parameter_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_function_parameter_token2] = { + .visible = true, + .named = false, + }, [aux_sym_function_statement_token1] = { .visible = true, .named = false, }, - [aux_sym_class_statement_token1] = { + [aux_sym_interface_statement_token1] = { .visible = true, .named = false, }, - [aux_sym_class_statement_token2] = { + [aux_sym_property_tuning_token1] = { .visible = true, .named = false, }, - [aux_sym_implements_token1] = { + [aux_sym_property_tuning_token2] = { .visible = true, .named = false, }, - [aux_sym_use_widget_pool_token1] = { + [aux_sym_getter_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_setter_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_property_definition_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_property_definition_token2] = { + .visible = true, + .named = false, + }, + [aux_sym_event_definition_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_event_definition_token2] = { + .visible = true, + .named = false, + }, + [aux_sym_method_definition_token1] = { .visible = true, .named = false, }, - [aux_sym_abstract_token1] = { + [aux_sym_data_relation_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_data_relation_token2] = { + .visible = true, + .named = false, + }, + [aux_sym_class_statement_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_inherits_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_implements_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_use_widget_pool_token1] = { .visible = true, .named = false, }, @@ -1664,6 +1812,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [aux_sym_output_stream_statement_token1] = { + .visible = true, + .named = false, + }, [aux_sym_on_error_phrase_token1] = { .visible = true, .named = false, @@ -1704,6 +1856,18 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [aux_sym_stop_after_phrase_token1] = { + .visible = true, + .named = false, + }, + [aux_sym_do_tuning_token1] = { + .visible = true, + .named = false, + }, + [anon_sym_BY] = { + .visible = true, + .named = false, + }, [aux_sym__case_terminator_token1] = { .visible = true, .named = false, @@ -1808,10 +1972,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [aux_sym_transaction_statement_token1] = { - .visible = true, - .named = false, - }, [aux_sym_assign_statement_token1] = { .visible = true, .named = false, @@ -1900,10 +2060,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, - [aux_sym_field_option_token1] = { - .visible = true, - .named = false, - }, [aux_sym_field_definition_token1] = { .visible = true, .named = false, @@ -2180,10 +2336,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_do_statement] = { - .visible = true, - .named = true, - }, [sym__procedure_terminator] = { .visible = false, .named = true, @@ -2216,10 +2368,54 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_interface_body] = { + .visible = true, + .named = true, + }, + [sym_interface_statement] = { + .visible = true, + .named = true, + }, + [sym_property_tuning] = { + .visible = true, + .named = true, + }, + [sym_getter] = { + .visible = true, + .named = true, + }, + [sym_setter] = { + .visible = true, + .named = true, + }, + [sym_property_definition] = { + .visible = true, + .named = true, + }, + [sym_event_definition] = { + .visible = true, + .named = true, + }, + [sym_method_definition] = { + .visible = true, + .named = true, + }, + [sym_data_relation] = { + .visible = true, + .named = true, + }, + [sym_dataset_definition] = { + .visible = true, + .named = true, + }, [sym_class_statement] = { .visible = true, .named = true, }, + [sym_inherits] = { + .visible = true, + .named = true, + }, [sym_implements] = { .visible = true, .named = true, @@ -2284,6 +2480,18 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, + [sym_stop_after_phrase] = { + .visible = true, + .named = true, + }, + [sym_do_tuning] = { + .visible = true, + .named = true, + }, + [sym_to_phrase] = { + .visible = true, + .named = true, + }, [sym_do_block] = { .visible = true, .named = true, @@ -2368,10 +2576,6 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = true, }, - [sym_transaction_statement] = { - .visible = true, - .named = true, - }, [sym_abl_statement] = { .visible = true, .named = true, @@ -2510,11 +2714,27 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, + [aux_sym_interface_body_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_property_definition_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_property_definition_repeat2] = { + .visible = false, + .named = false, + }, + [aux_sym_data_relation_repeat1] = { + .visible = false, + .named = false, + }, [aux_sym_class_statement_repeat1] = { .visible = false, .named = false, }, - [aux_sym_implements_repeat1] = { + [aux_sym_inherits_repeat1] = { .visible = false, .named = false, }, @@ -2522,6 +2742,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = false, .named = false, }, + [aux_sym_do_block_repeat1] = { + .visible = false, + .named = false, + }, [aux_sym_case_body_repeat1] = { .visible = false, .named = false, @@ -2601,23 +2825,22 @@ enum { field_field = 6, field_frame = 7, field_function = 8, - field_inherits = 9, - field_label = 10, - field_like = 11, - field_method = 12, - field_name = 13, - field_property = 14, - field_return_type = 15, - field_source = 16, - field_statement = 17, - field_stream = 18, - field_stream_handle = 19, - field_table = 20, - field_target = 21, - field_then = 22, - field_type = 23, - field_value = 24, - field_variable = 25, + field_label = 9, + field_like = 10, + field_method = 11, + field_name = 12, + field_property = 13, + field_return_type = 14, + field_source = 15, + field_statement = 16, + field_stream = 17, + field_stream_handle = 18, + field_table = 19, + field_target = 20, + field_then = 21, + field_type = 22, + field_value = 23, + field_variable = 24, }; static const char * const ts_field_names[] = { @@ -2630,7 +2853,6 @@ static const char * const ts_field_names[] = { [field_field] = "field", [field_frame] = "frame", [field_function] = "function", - [field_inherits] = "inherits", [field_label] = "label", [field_like] = "like", [field_method] = "method", @@ -2663,50 +2885,53 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [11] = {.index = 11, .length = 4}, [12] = {.index = 15, .length = 1}, [13] = {.index = 16, .length = 1}, - [14] = {.index = 17, .length = 1}, - [15] = {.index = 18, .length = 2}, - [16] = {.index = 20, .length = 2}, + [14] = {.index = 17, .length = 2}, + [15] = {.index = 19, .length = 2}, + [16] = {.index = 21, .length = 1}, [17] = {.index = 22, .length = 2}, [18] = {.index = 24, .length = 1}, - [19] = {.index = 25, .length = 2}, - [20] = {.index = 27, .length = 1}, - [21] = {.index = 28, .length = 1}, - [22] = {.index = 29, .length = 1}, - [23] = {.index = 30, .length = 1}, - [24] = {.index = 31, .length = 1}, - [25] = {.index = 32, .length = 1}, - [26] = {.index = 33, .length = 1}, - [27] = {.index = 34, .length = 2}, + [19] = {.index = 25, .length = 1}, + [20] = {.index = 26, .length = 1}, + [21] = {.index = 27, .length = 1}, + [22] = {.index = 28, .length = 1}, + [23] = {.index = 29, .length = 1}, + [24] = {.index = 30, .length = 1}, + [25] = {.index = 31, .length = 2}, + [26] = {.index = 33, .length = 2}, + [27] = {.index = 35, .length = 1}, [28] = {.index = 36, .length = 2}, - [29] = {.index = 38, .length = 1}, - [30] = {.index = 39, .length = 2}, - [31] = {.index = 41, .length = 2}, - [32] = {.index = 43, .length = 2}, + [29] = {.index = 38, .length = 2}, + [30] = {.index = 40, .length = 2}, + [31] = {.index = 42, .length = 2}, + [32] = {.index = 44, .length = 1}, [33] = {.index = 45, .length = 2}, [34] = {.index = 47, .length = 1}, [35] = {.index = 48, .length = 2}, [36] = {.index = 50, .length = 1}, [37] = {.index = 51, .length = 2}, - [38] = {.index = 53, .length = 2}, - [39] = {.index = 55, .length = 1}, - [40] = {.index = 56, .length = 2}, - [41] = {.index = 58, .length = 3}, + [38] = {.index = 53, .length = 3}, + [39] = {.index = 56, .length = 2}, + [40] = {.index = 58, .length = 2}, + [41] = {.index = 60, .length = 1}, [42] = {.index = 61, .length = 2}, [43] = {.index = 63, .length = 2}, - [44] = {.index = 65, .length = 1}, - [45] = {.index = 66, .length = 2}, - [46] = {.index = 68, .length = 2}, - [47] = {.index = 70, .length = 2}, - [48] = {.index = 72, .length = 1}, - [49] = {.index = 73, .length = 1}, - [50] = {.index = 74, .length = 2}, - [51] = {.index = 76, .length = 2}, + [44] = {.index = 65, .length = 2}, + [45] = {.index = 67, .length = 1}, + [46] = {.index = 68, .length = 1}, + [47] = {.index = 69, .length = 2}, + [48] = {.index = 71, .length = 2}, + [49] = {.index = 73, .length = 2}, + [50] = {.index = 75, .length = 2}, + [51] = {.index = 77, .length = 1}, [52] = {.index = 78, .length = 2}, - [53] = {.index = 80, .length = 2}, - [54] = {.index = 82, .length = 1}, - [55] = {.index = 83, .length = 2}, - [56] = {.index = 85, .length = 3}, - [57] = {.index = 88, .length = 1}, + [53] = {.index = 80, .length = 1}, + [54] = {.index = 81, .length = 3}, + [55] = {.index = 84, .length = 1}, + [56] = {.index = 85, .length = 1}, + [57] = {.index = 86, .length = 1}, + [58] = {.index = 87, .length = 1}, + [59] = {.index = 88, .length = 1}, + [60] = {.index = 89, .length = 1}, }; static const TSFieldMapEntry ts_field_map_entries[] = { @@ -2741,121 +2966,125 @@ static const TSFieldMapEntry ts_field_map_entries[] = { [16] = {field_condition, 1, .inherited = true}, [17] = - {field_inherits, 1}, - [18] = - {field_inherits, 0, .inherited = true}, - {field_inherits, 1, .inherited = true}, - [20] = {field_table, 2}, {field_type, 1}, - [22] = + [19] = {field_field, 3}, {field_frame, 2}, - [24] = + [21] = {field_table, 2}, - [25] = + [22] = {field_field, 0, .inherited = true}, {field_frame, 0, .inherited = true}, - [27] = + [24] = {field_stream, 2}, - [28] = + [25] = {field_stream_handle, 2}, - [29] = + [26] = {field_column, 0}, - [30] = + [27] = {field_name, 1}, - [31] = + [28] = {field_label, 1}, - [32] = + [29] = {field_label, 3}, - [33] = + [30] = {field_condition, 2, .inherited = true}, - [34] = + [31] = {field_name, 1}, {field_value, 3}, - [36] = + [33] = {field_constant, 3}, {field_table, 2}, - [38] = + [35] = {field_table, 3}, - [39] = + [36] = {field_source, 2}, {field_target, 4}, - [41] = + [38] = {field_name, 2}, {field_type, 4}, - [43] = + [40] = {field_like, 4}, {field_name, 2}, - [45] = + [42] = {field_name, 2}, {field_table, 4}, - [47] = + [44] = {field_name, 2}, - [48] = + [45] = {field_table, 1}, {field_type, 0}, - [50] = + [47] = {field_label, 4}, - [51] = - {field_inherits, 2, .inherited = true}, - {field_name, 1}, - [53] = + [48] = {field_label, 1}, {field_label, 4}, - [55] = + [50] = {field_body, 1}, - [56] = + [51] = {field_table, 3}, {field_type, 2}, - [58] = + [53] = {field_condition, 1}, {field_else, 5}, {field_then, 3}, - [61] = + [56] = {field_constant, 4}, {field_table, 3}, - [63] = + [58] = {field_name, 2}, {field_table, 5}, - [65] = + [60] = {field_like, 3}, - [66] = + [61] = {field_name, 3}, {field_type, 5}, - [68] = + [63] = {field_like, 5}, {field_name, 3}, - [70] = + [65] = {field_name, 3}, {field_table, 5}, - [72] = + [67] = {field_name, 3}, - [73] = + [68] = {field_label, 5}, - [74] = + [69] = {field_body, 3}, {field_value, 1}, - [76] = + [71] = {field_type, 3}, {field_variable, 1}, - [78] = + [73] = {field_name, 3}, {field_table, 6}, - [80] = + [75] = {field_label, 3}, {field_label, 6}, - [82] = + [77] = {field_label, 6}, - [83] = + [78] = {field_name, 1}, {field_return_type, 3}, - [85] = + [80] = + {field_like, 4}, + [81] = {field_type, 3}, {field_type, 4}, {field_variable, 1}, - [88] = + [84] = {field_condition, 2}, + [85] = + {field_like, 5}, + [86] = + {field_return_type, 1}, + [87] = + {field_like, 6}, + [88] = + {field_return_type, 2}, + [89] = + {field_like, 7}, }; static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { @@ -2872,18 +3101,18 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [2] = 2, [3] = 3, [4] = 4, - [5] = 5, + [5] = 4, [6] = 6, [7] = 7, - [8] = 3, - [9] = 5, + [8] = 8, + [9] = 9, [10] = 6, [11] = 7, - [12] = 2, - [13] = 4, + [12] = 8, + [13] = 13, [14] = 14, - [15] = 15, - [16] = 16, + [15] = 9, + [16] = 14, [17] = 17, [18] = 18, [19] = 19, @@ -2901,276 +3130,276 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [31] = 31, [32] = 32, [33] = 33, - [34] = 14, + [34] = 34, [35] = 35, [36] = 36, - [37] = 37, + [37] = 35, [38] = 38, [39] = 39, [40] = 40, [41] = 41, - [42] = 14, + [42] = 42, [43] = 43, - [44] = 41, + [44] = 44, [45] = 45, - [46] = 40, - [47] = 38, + [46] = 46, + [47] = 47, [48] = 48, - [49] = 31, - [50] = 30, - [51] = 39, - [52] = 37, - [53] = 18, - [54] = 36, + [49] = 49, + [50] = 50, + [51] = 51, + [52] = 52, + [53] = 46, + [54] = 38, [55] = 55, [56] = 56, [57] = 57, - [58] = 35, + [58] = 58, [59] = 59, [60] = 60, - [61] = 33, - [62] = 43, + [61] = 61, + [62] = 18, [63] = 63, [64] = 64, [65] = 65, [66] = 66, [67] = 67, [68] = 68, - [69] = 69, - [70] = 70, - [71] = 71, - [72] = 18, - [73] = 73, - [74] = 16, - [75] = 17, - [76] = 76, - [77] = 77, - [78] = 19, - [79] = 20, - [80] = 21, - [81] = 22, - [82] = 23, - [83] = 24, - [84] = 25, - [85] = 26, - [86] = 27, - [87] = 28, - [88] = 29, - [89] = 32, - [90] = 60, - [91] = 33, - [92] = 35, - [93] = 36, - [94] = 37, - [95] = 38, - [96] = 32, - [97] = 40, - [98] = 59, - [99] = 41, - [100] = 14, - [101] = 48, - [102] = 31, - [103] = 30, - [104] = 39, - [105] = 29, - [106] = 18, - [107] = 63, - [108] = 55, - [109] = 56, - [110] = 57, + [69] = 68, + [70] = 65, + [71] = 59, + [72] = 52, + [73] = 51, + [74] = 50, + [75] = 49, + [76] = 48, + [77] = 47, + [78] = 45, + [79] = 44, + [80] = 43, + [81] = 42, + [82] = 41, + [83] = 40, + [84] = 60, + [85] = 55, + [86] = 39, + [87] = 35, + [88] = 61, + [89] = 36, + [90] = 90, + [91] = 34, + [92] = 33, + [93] = 46, + [94] = 32, + [95] = 95, + [96] = 19, + [97] = 18, + [98] = 63, + [99] = 17, + [100] = 38, + [101] = 101, + [102] = 20, + [103] = 21, + [104] = 22, + [105] = 64, + [106] = 23, + [107] = 24, + [108] = 25, + [109] = 26, + [110] = 27, [111] = 28, - [112] = 59, - [113] = 60, - [114] = 43, - [115] = 63, - [116] = 64, - [117] = 65, - [118] = 66, - [119] = 67, - [120] = 68, - [121] = 69, - [122] = 27, - [123] = 70, - [124] = 71, - [125] = 15, - [126] = 73, - [127] = 16, - [128] = 17, - [129] = 76, - [130] = 19, - [131] = 20, - [132] = 26, - [133] = 21, + [112] = 29, + [113] = 30, + [114] = 59, + [115] = 31, + [116] = 67, + [117] = 66, + [118] = 60, + [119] = 64, + [120] = 63, + [121] = 18, + [122] = 31, + [123] = 30, + [124] = 29, + [125] = 28, + [126] = 27, + [127] = 26, + [128] = 25, + [129] = 24, + [130] = 66, + [131] = 46, + [132] = 38, + [133] = 23, [134] = 22, - [135] = 23, - [136] = 24, - [137] = 25, - [138] = 26, - [139] = 27, - [140] = 28, - [141] = 29, + [135] = 21, + [136] = 20, + [137] = 101, + [138] = 95, + [139] = 19, + [140] = 55, + [141] = 95, [142] = 32, [143] = 33, - [144] = 25, - [145] = 35, + [144] = 34, + [145] = 90, [146] = 36, - [147] = 37, - [148] = 38, - [149] = 24, - [150] = 40, - [151] = 41, - [152] = 15, - [153] = 48, - [154] = 31, - [155] = 23, - [156] = 30, + [147] = 90, + [148] = 17, + [149] = 56, + [150] = 41, + [151] = 56, + [152] = 58, + [153] = 42, + [154] = 60, + [155] = 61, + [156] = 43, [157] = 39, - [158] = 56, - [159] = 73, - [160] = 76, - [161] = 55, - [162] = 22, - [163] = 57, - [164] = 21, - [165] = 59, - [166] = 60, - [167] = 43, - [168] = 63, - [169] = 64, - [170] = 65, - [171] = 66, - [172] = 67, - [173] = 68, - [174] = 69, - [175] = 70, - [176] = 71, - [177] = 15, - [178] = 73, - [179] = 16, - [180] = 17, - [181] = 76, - [182] = 48, - [183] = 19, - [184] = 184, - [185] = 20, - [186] = 21, - [187] = 22, - [188] = 23, - [189] = 24, - [190] = 25, - [191] = 26, - [192] = 27, - [193] = 28, - [194] = 29, - [195] = 32, - [196] = 77, - [197] = 33, - [198] = 35, - [199] = 36, - [200] = 37, - [201] = 38, - [202] = 20, - [203] = 40, - [204] = 45, - [205] = 41, - [206] = 71, - [207] = 14, - [208] = 48, - [209] = 31, - [210] = 30, - [211] = 39, - [212] = 184, - [213] = 18, - [214] = 64, - [215] = 19, - [216] = 55, - [217] = 217, - [218] = 218, - [219] = 76, - [220] = 56, - [221] = 57, - [222] = 17, - [223] = 59, - [224] = 57, - [225] = 60, - [226] = 70, - [227] = 69, - [228] = 56, - [229] = 16, - [230] = 65, - [231] = 73, - [232] = 68, - [233] = 15, - [234] = 66, - [235] = 218, - [236] = 71, - [237] = 217, - [238] = 55, - [239] = 70, - [240] = 67, - [241] = 69, - [242] = 68, - [243] = 67, - [244] = 66, - [245] = 65, - [246] = 64, - [247] = 63, - [248] = 43, - [249] = 249, - [250] = 250, - [251] = 251, - [252] = 250, - [253] = 253, - [254] = 254, - [255] = 255, - [256] = 251, - [257] = 254, - [258] = 255, - [259] = 253, - [260] = 249, - [261] = 261, - [262] = 262, - [263] = 262, - [264] = 264, - [265] = 264, - [266] = 266, - [267] = 266, - [268] = 262, - [269] = 266, - [270] = 262, - [271] = 266, - [272] = 266, - [273] = 262, + [158] = 44, + [159] = 45, + [160] = 47, + [161] = 63, + [162] = 48, + [163] = 64, + [164] = 49, + [165] = 50, + [166] = 51, + [167] = 52, + [168] = 66, + [169] = 59, + [170] = 67, + [171] = 68, + [172] = 59, + [173] = 52, + [174] = 61, + [175] = 51, + [176] = 50, + [177] = 49, + [178] = 48, + [179] = 47, + [180] = 45, + [181] = 44, + [182] = 43, + [183] = 68, + [184] = 42, + [185] = 67, + [186] = 66, + [187] = 41, + [188] = 40, + [189] = 64, + [190] = 63, + [191] = 18, + [192] = 61, + [193] = 39, + [194] = 35, + [195] = 36, + [196] = 90, + [197] = 34, + [198] = 33, + [199] = 60, + [200] = 32, + [201] = 58, + [202] = 95, + [203] = 56, + [204] = 55, + [205] = 19, + [206] = 17, + [207] = 101, + [208] = 38, + [209] = 46, + [210] = 20, + [211] = 21, + [212] = 60, + [213] = 31, + [214] = 30, + [215] = 29, + [216] = 28, + [217] = 27, + [218] = 26, + [219] = 25, + [220] = 24, + [221] = 22, + [222] = 23, + [223] = 23, + [224] = 22, + [225] = 21, + [226] = 20, + [227] = 24, + [228] = 25, + [229] = 101, + [230] = 17, + [231] = 19, + [232] = 55, + [233] = 95, + [234] = 32, + [235] = 33, + [236] = 40, + [237] = 34, + [238] = 90, + [239] = 36, + [240] = 35, + [241] = 39, + [242] = 40, + [243] = 26, + [244] = 27, + [245] = 57, + [246] = 58, + [247] = 41, + [248] = 28, + [249] = 42, + [250] = 43, + [251] = 44, + [252] = 58, + [253] = 45, + [254] = 47, + [255] = 48, + [256] = 49, + [257] = 50, + [258] = 51, + [259] = 67, + [260] = 52, + [261] = 29, + [262] = 59, + [263] = 30, + [264] = 31, + [265] = 68, + [266] = 101, + [267] = 56, + [268] = 268, + [269] = 269, + [270] = 270, + [271] = 269, + [272] = 268, + [273] = 270, [274] = 274, [275] = 275, - [276] = 276, - [277] = 277, + [276] = 274, + [277] = 275, [278] = 278, [279] = 279, - [280] = 280, + [280] = 279, [281] = 281, [282] = 282, - [283] = 283, - [284] = 284, - [285] = 285, + [283] = 279, + [284] = 278, + [285] = 279, [286] = 286, - [287] = 287, - [288] = 288, - [289] = 288, - [290] = 290, - [291] = 291, - [292] = 291, - [293] = 288, - [294] = 291, - [295] = 291, - [296] = 291, - [297] = 291, + [287] = 278, + [288] = 279, + [289] = 278, + [290] = 282, + [291] = 279, + [292] = 278, + [293] = 278, + [294] = 294, + [295] = 295, + [296] = 296, + [297] = 297, [298] = 298, - [299] = 291, - [300] = 288, - [301] = 291, - [302] = 288, - [303] = 288, + [299] = 299, + [300] = 300, + [301] = 301, + [302] = 302, + [303] = 303, [304] = 304, [305] = 305, [306] = 306, @@ -3180,1408 +3409,1408 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [310] = 310, [311] = 311, [312] = 312, - [313] = 313, - [314] = 314, + [313] = 304, + [314] = 304, [315] = 315, - [316] = 316, - [317] = 317, - [318] = 318, + [316] = 304, + [317] = 304, + [318] = 315, [319] = 319, [320] = 320, [321] = 321, [322] = 322, [323] = 323, - [324] = 324, - [325] = 325, + [324] = 315, + [325] = 304, [326] = 326, [327] = 327, [328] = 328, [329] = 329, - [330] = 330, - [331] = 329, - [332] = 329, - [333] = 329, - [334] = 329, + [330] = 315, + [331] = 331, + [332] = 304, + [333] = 304, + [334] = 315, [335] = 335, - [336] = 336, - [337] = 337, + [336] = 315, + [337] = 304, [338] = 338, [339] = 339, - [340] = 340, + [340] = 315, [341] = 341, [342] = 342, - [343] = 304, - [344] = 298, - [345] = 311, + [343] = 343, + [344] = 344, + [345] = 345, [346] = 346, [347] = 347, - [348] = 348, - [349] = 314, + [348] = 347, + [349] = 347, [350] = 350, - [351] = 351, - [352] = 352, + [351] = 347, + [352] = 347, [353] = 353, - [354] = 353, + [354] = 354, [355] = 355, - [356] = 353, - [357] = 353, - [358] = 353, + [356] = 356, + [357] = 357, + [358] = 358, [359] = 359, - [360] = 276, - [361] = 359, - [362] = 359, - [363] = 330, - [364] = 287, - [365] = 359, - [366] = 286, - [367] = 359, - [368] = 335, - [369] = 275, + [360] = 360, + [361] = 361, + [362] = 362, + [363] = 344, + [364] = 364, + [365] = 345, + [366] = 302, + [367] = 367, + [368] = 303, + [369] = 369, [370] = 370, [371] = 371, - [372] = 372, + [372] = 371, [373] = 373, - [374] = 374, - [375] = 375, - [376] = 376, - [377] = 377, - [378] = 378, + [374] = 371, + [375] = 371, + [376] = 371, + [377] = 342, + [378] = 353, [379] = 379, - [380] = 375, - [381] = 381, - [382] = 382, - [383] = 377, - [384] = 384, - [385] = 372, - [386] = 371, - [387] = 387, + [380] = 2, + [381] = 379, + [382] = 379, + [383] = 343, + [384] = 350, + [385] = 3, + [386] = 379, + [387] = 379, [388] = 388, - [389] = 370, + [389] = 303, [390] = 390, [391] = 391, [392] = 392, [393] = 393, - [394] = 384, - [395] = 382, - [396] = 378, - [397] = 397, - [398] = 371, + [394] = 394, + [395] = 395, + [396] = 396, + [397] = 388, + [398] = 390, [399] = 399, - [400] = 400, - [401] = 401, - [402] = 370, - [403] = 298, - [404] = 392, - [405] = 387, - [406] = 397, - [407] = 387, - [408] = 408, - [409] = 392, - [410] = 341, - [411] = 375, - [412] = 336, - [413] = 375, - [414] = 372, - [415] = 415, - [416] = 400, - [417] = 372, - [418] = 371, - [419] = 388, - [420] = 388, - [421] = 382, - [422] = 422, - [423] = 384, - [424] = 370, - [425] = 370, - [426] = 370, - [427] = 388, - [428] = 374, - [429] = 372, - [430] = 378, - [431] = 375, - [432] = 370, - [433] = 392, - [434] = 397, - [435] = 400, - [436] = 384, - [437] = 382, - [438] = 378, - [439] = 371, - [440] = 388, - [441] = 400, - [442] = 442, - [443] = 382, - [444] = 384, - [445] = 378, - [446] = 400, - [447] = 371, - [448] = 378, - [449] = 382, - [450] = 382, - [451] = 378, - [452] = 387, - [453] = 371, - [454] = 454, - [455] = 371, - [456] = 456, - [457] = 277, - [458] = 458, - [459] = 400, - [460] = 400, - [461] = 392, - [462] = 392, - [463] = 463, + [400] = 392, + [401] = 396, + [402] = 402, + [403] = 403, + [404] = 404, + [405] = 395, + [406] = 394, + [407] = 394, + [408] = 404, + [409] = 403, + [410] = 402, + [411] = 392, + [412] = 404, + [413] = 403, + [414] = 402, + [415] = 392, + [416] = 416, + [417] = 393, + [418] = 393, + [419] = 402, + [420] = 393, + [421] = 421, + [422] = 390, + [423] = 395, + [424] = 396, + [425] = 388, + [426] = 390, + [427] = 302, + [428] = 421, + [429] = 404, + [430] = 403, + [431] = 431, + [432] = 432, + [433] = 433, + [434] = 434, + [435] = 435, + [436] = 421, + [437] = 437, + [438] = 416, + [439] = 439, + [440] = 440, + [441] = 441, + [442] = 390, + [443] = 434, + [444] = 433, + [445] = 445, + [446] = 402, + [447] = 392, + [448] = 431, + [449] = 449, + [450] = 450, + [451] = 392, + [452] = 434, + [453] = 416, + [454] = 434, + [455] = 416, + [456] = 402, + [457] = 434, + [458] = 416, + [459] = 434, + [460] = 416, + [461] = 416, + [462] = 393, + [463] = 416, [464] = 464, - [465] = 372, - [466] = 375, - [467] = 401, - [468] = 375, - [469] = 388, - [470] = 400, - [471] = 442, - [472] = 372, - [473] = 387, - [474] = 387, + [465] = 465, + [466] = 432, + [467] = 388, + [468] = 403, + [469] = 469, + [470] = 390, + [471] = 404, + [472] = 388, + [473] = 404, + [474] = 396, [475] = 388, - [476] = 476, - [477] = 376, - [478] = 456, + [476] = 395, + [477] = 445, + [478] = 396, [479] = 479, - [480] = 397, - [481] = 415, - [482] = 381, - [483] = 372, - [484] = 484, - [485] = 304, - [486] = 373, - [487] = 381, - [488] = 381, - [489] = 384, - [490] = 379, - [491] = 392, - [492] = 283, - [493] = 381, - [494] = 384, - [495] = 408, - [496] = 382, - [497] = 378, - [498] = 387, - [499] = 384, - [500] = 484, - [501] = 501, - [502] = 388, - [503] = 370, - [504] = 397, - [505] = 391, - [506] = 375, - [507] = 454, - [508] = 381, - [509] = 392, - [510] = 381, - [511] = 387, - [512] = 479, - [513] = 381, - [514] = 463, - [515] = 319, - [516] = 318, - [517] = 327, - [518] = 284, - [519] = 315, - [520] = 282, - [521] = 280, - [522] = 320, - [523] = 305, - [524] = 306, - [525] = 285, - [526] = 281, - [527] = 323, - [528] = 316, - [529] = 313, - [530] = 317, - [531] = 279, - [532] = 326, - [533] = 307, - [534] = 310, - [535] = 309, - [536] = 278, - [537] = 321, - [538] = 322, - [539] = 324, - [540] = 312, - [541] = 308, - [542] = 325, - [543] = 352, - [544] = 339, - [545] = 346, - [546] = 347, - [547] = 340, - [548] = 350, - [549] = 351, - [550] = 338, - [551] = 337, - [552] = 348, - [553] = 393, - [554] = 464, - [555] = 555, - [556] = 555, - [557] = 557, - [558] = 557, - [559] = 557, - [560] = 555, - [561] = 555, - [562] = 557, - [563] = 555, - [564] = 557, - [565] = 393, - [566] = 464, - [567] = 311, - [568] = 314, - [569] = 339, - [570] = 346, - [571] = 347, + [480] = 394, + [481] = 399, + [482] = 396, + [483] = 395, + [484] = 395, + [485] = 485, + [486] = 394, + [487] = 394, + [488] = 488, + [489] = 421, + [490] = 421, + [491] = 469, + [492] = 421, + [493] = 493, + [494] = 390, + [495] = 421, + [496] = 496, + [497] = 439, + [498] = 498, + [499] = 388, + [500] = 392, + [501] = 402, + [502] = 403, + [503] = 396, + [504] = 395, + [505] = 394, + [506] = 393, + [507] = 416, + [508] = 404, + [509] = 393, + [510] = 421, + [511] = 498, + [512] = 464, + [513] = 421, + [514] = 496, + [515] = 488, + [516] = 485, + [517] = 449, + [518] = 404, + [519] = 403, + [520] = 520, + [521] = 402, + [522] = 403, + [523] = 404, + [524] = 393, + [525] = 367, + [526] = 369, + [527] = 395, + [528] = 393, + [529] = 396, + [530] = 388, + [531] = 392, + [532] = 299, + [533] = 390, + [534] = 493, + [535] = 394, + [536] = 395, + [537] = 396, + [538] = 388, + [539] = 390, + [540] = 437, + [541] = 394, + [542] = 403, + [543] = 13, + [544] = 391, + [545] = 392, + [546] = 402, + [547] = 296, + [548] = 298, + [549] = 300, + [550] = 326, + [551] = 295, + [552] = 294, + [553] = 320, + [554] = 312, + [555] = 335, + [556] = 310, + [557] = 319, + [558] = 297, + [559] = 341, + [560] = 327, + [561] = 339, + [562] = 321, + [563] = 308, + [564] = 322, + [565] = 306, + [566] = 328, + [567] = 329, + [568] = 331, + [569] = 323, + [570] = 309, + [571] = 307, [572] = 338, - [573] = 352, - [574] = 350, - [575] = 575, - [576] = 347, - [577] = 348, - [578] = 352, - [579] = 338, - [580] = 575, - [581] = 337, - [582] = 351, - [583] = 337, - [584] = 346, - [585] = 275, - [586] = 351, - [587] = 340, - [588] = 340, - [589] = 339, - [590] = 348, - [591] = 276, - [592] = 350, - [593] = 311, - [594] = 277, - [595] = 314, - [596] = 336, - [597] = 348, - [598] = 352, - [599] = 599, - [600] = 338, - [601] = 351, - [602] = 330, - [603] = 350, - [604] = 346, - [605] = 335, - [606] = 337, - [607] = 339, - [608] = 347, - [609] = 340, - [610] = 610, - [611] = 611, - [612] = 341, - [613] = 613, - [614] = 610, - [615] = 613, - [616] = 611, - [617] = 335, - [618] = 287, - [619] = 286, - [620] = 336, - [621] = 330, + [573] = 301, + [574] = 305, + [575] = 355, + [576] = 358, + [577] = 359, + [578] = 370, + [579] = 360, + [580] = 361, + [581] = 354, + [582] = 356, + [583] = 362, + [584] = 364, + [585] = 585, + [586] = 586, + [587] = 586, + [588] = 586, + [589] = 585, + [590] = 585, + [591] = 585, + [592] = 586, + [593] = 586, + [594] = 585, + [595] = 585, + [596] = 586, + [597] = 345, + [598] = 344, + [599] = 364, + [600] = 361, + [601] = 355, + [602] = 354, + [603] = 355, + [604] = 358, + [605] = 605, + [606] = 605, + [607] = 358, + [608] = 359, + [609] = 360, + [610] = 359, + [611] = 370, + [612] = 362, + [613] = 370, + [614] = 354, + [615] = 361, + [616] = 360, + [617] = 356, + [618] = 356, + [619] = 362, + [620] = 364, + [621] = 621, [622] = 622, - [623] = 341, - [624] = 464, - [625] = 393, - [626] = 298, - [627] = 304, - [628] = 283, - [629] = 629, - [630] = 321, - [631] = 327, - [632] = 323, - [633] = 280, - [634] = 312, - [635] = 317, - [636] = 282, - [637] = 278, - [638] = 319, - [639] = 279, - [640] = 284, - [641] = 324, - [642] = 281, - [643] = 285, - [644] = 275, - [645] = 325, - [646] = 326, - [647] = 314, - [648] = 309, - [649] = 308, - [650] = 310, - [651] = 311, + [623] = 621, + [624] = 624, + [625] = 624, + [626] = 622, + [627] = 343, + [628] = 350, + [629] = 342, + [630] = 353, + [631] = 631, + [632] = 369, + [633] = 464, + [634] = 299, + [635] = 464, + [636] = 303, + [637] = 367, + [638] = 485, + [639] = 485, + [640] = 302, + [641] = 309, + [642] = 335, + [643] = 295, + [644] = 297, + [645] = 326, + [646] = 301, + [647] = 327, + [648] = 308, + [649] = 307, + [650] = 298, + [651] = 296, [652] = 305, - [653] = 276, - [654] = 320, - [655] = 316, - [656] = 307, - [657] = 306, - [658] = 315, + [653] = 294, + [654] = 321, + [655] = 306, + [656] = 328, + [657] = 657, + [658] = 323, [659] = 322, - [660] = 313, - [661] = 318, - [662] = 351, - [663] = 352, - [664] = 348, - [665] = 314, - [666] = 346, - [667] = 347, - [668] = 350, - [669] = 669, - [670] = 338, - [671] = 339, - [672] = 340, - [673] = 337, - [674] = 277, - [675] = 675, - [676] = 675, - [677] = 311, - [678] = 352, - [679] = 350, - [680] = 348, - [681] = 351, - [682] = 347, - [683] = 346, - [684] = 337, - [685] = 338, - [686] = 339, - [687] = 687, - [688] = 340, - [689] = 348, - [690] = 335, - [691] = 287, - [692] = 692, - [693] = 693, - [694] = 275, - [695] = 338, - [696] = 696, - [697] = 339, - [698] = 687, - [699] = 336, - [700] = 351, - [701] = 347, - [702] = 350, - [703] = 330, - [704] = 276, - [705] = 352, - [706] = 346, - [707] = 337, - [708] = 340, - [709] = 286, - [710] = 710, - [711] = 711, - [712] = 712, + [660] = 341, + [661] = 310, + [662] = 338, + [663] = 312, + [664] = 300, + [665] = 331, + [666] = 329, + [667] = 319, + [668] = 339, + [669] = 320, + [670] = 344, + [671] = 345, + [672] = 344, + [673] = 345, + [674] = 362, + [675] = 362, + [676] = 345, + [677] = 677, + [678] = 2, + [679] = 344, + [680] = 370, + [681] = 681, + [682] = 361, + [683] = 361, + [684] = 360, + [685] = 359, + [686] = 3, + [687] = 360, + [688] = 359, + [689] = 358, + [690] = 358, + [691] = 364, + [692] = 355, + [693] = 354, + [694] = 356, + [695] = 355, + [696] = 370, + [697] = 354, + [698] = 364, + [699] = 356, + [700] = 356, + [701] = 701, + [702] = 344, + [703] = 13, + [704] = 360, + [705] = 364, + [706] = 359, + [707] = 355, + [708] = 362, + [709] = 345, + [710] = 354, + [711] = 361, + [712] = 358, [713] = 713, - [714] = 714, - [715] = 715, - [716] = 714, - [717] = 717, - [718] = 718, - [719] = 719, - [720] = 720, - [721] = 710, - [722] = 393, - [723] = 723, - [724] = 724, - [725] = 714, - [726] = 712, - [727] = 723, - [728] = 715, - [729] = 286, - [730] = 730, - [731] = 731, - [732] = 730, - [733] = 464, - [734] = 341, - [735] = 714, - [736] = 714, - [737] = 298, - [738] = 277, - [739] = 712, - [740] = 711, - [741] = 335, - [742] = 283, - [743] = 743, - [744] = 717, - [745] = 711, - [746] = 719, - [747] = 720, - [748] = 330, - [749] = 276, - [750] = 718, - [751] = 336, - [752] = 287, - [753] = 714, - [754] = 743, - [755] = 714, - [756] = 743, - [757] = 714, - [758] = 711, - [759] = 743, - [760] = 304, - [761] = 712, - [762] = 275, - [763] = 711, - [764] = 712, - [765] = 712, - [766] = 712, - [767] = 712, - [768] = 743, - [769] = 713, - [770] = 731, - [771] = 313, - [772] = 317, - [773] = 280, - [774] = 306, - [775] = 315, - [776] = 309, - [777] = 323, - [778] = 322, - [779] = 277, - [780] = 312, - [781] = 282, - [782] = 284, - [783] = 341, - [784] = 285, + [714] = 701, + [715] = 370, + [716] = 2, + [717] = 369, + [718] = 342, + [719] = 344, + [720] = 356, + [721] = 342, + [722] = 350, + [723] = 3, + [724] = 3, + [725] = 354, + [726] = 343, + [727] = 370, + [728] = 360, + [729] = 364, + [730] = 362, + [731] = 677, + [732] = 353, + [733] = 2, + [734] = 345, + [735] = 355, + [736] = 353, + [737] = 737, + [738] = 350, + [739] = 358, + [740] = 359, + [741] = 369, + [742] = 361, + [743] = 343, + [744] = 353, + [745] = 367, + [746] = 746, + [747] = 747, + [748] = 748, + [749] = 737, + [750] = 750, + [751] = 355, + [752] = 370, + [753] = 354, + [754] = 356, + [755] = 364, + [756] = 358, + [757] = 359, + [758] = 360, + [759] = 367, + [760] = 13, + [761] = 361, + [762] = 13, + [763] = 3, + [764] = 2, + [765] = 362, + [766] = 350, + [767] = 369, + [768] = 343, + [769] = 302, + [770] = 303, + [771] = 464, + [772] = 342, + [773] = 299, + [774] = 485, + [775] = 775, + [776] = 775, + [777] = 295, + [778] = 778, + [779] = 775, + [780] = 780, + [781] = 781, + [782] = 782, + [783] = 778, + [784] = 312, [785] = 319, - [786] = 278, - [787] = 316, - [788] = 308, - [789] = 325, - [790] = 326, - [791] = 310, - [792] = 327, - [793] = 304, - [794] = 324, - [795] = 321, - [796] = 318, - [797] = 283, - [798] = 281, - [799] = 307, - [800] = 298, - [801] = 279, - [802] = 320, - [803] = 305, - [804] = 284, - [805] = 326, - [806] = 306, - [807] = 280, - [808] = 312, - [809] = 282, - [810] = 308, - [811] = 811, - [812] = 317, - [813] = 307, - [814] = 323, - [815] = 281, - [816] = 320, - [817] = 817, - [818] = 811, - [819] = 305, - [820] = 820, - [821] = 310, - [822] = 321, - [823] = 324, - [824] = 309, - [825] = 285, - [826] = 278, - [827] = 279, - [828] = 316, - [829] = 817, - [830] = 319, - [831] = 464, - [832] = 313, - [833] = 393, - [834] = 318, - [835] = 327, - [836] = 322, - [837] = 325, - [838] = 315, - [839] = 820, - [840] = 840, - [841] = 840, - [842] = 840, - [843] = 840, - [844] = 840, - [845] = 845, - [846] = 845, - [847] = 845, - [848] = 845, - [849] = 845, - [850] = 850, - [851] = 851, + [786] = 320, + [787] = 321, + [788] = 327, + [789] = 328, + [790] = 329, + [791] = 331, + [792] = 338, + [793] = 322, + [794] = 306, + [795] = 310, + [796] = 297, + [797] = 300, + [798] = 299, + [799] = 781, + [800] = 800, + [801] = 801, + [802] = 326, + [803] = 775, + [804] = 339, + [805] = 775, + [806] = 801, + [807] = 781, + [808] = 775, + [809] = 778, + [810] = 341, + [811] = 335, + [812] = 812, + [813] = 294, + [814] = 2, + [815] = 353, + [816] = 781, + [817] = 305, + [818] = 296, + [819] = 301, + [820] = 343, + [821] = 309, + [822] = 822, + [823] = 823, + [824] = 307, + [825] = 308, + [826] = 781, + [827] = 812, + [828] = 780, + [829] = 298, + [830] = 323, + [831] = 369, + [832] = 775, + [833] = 3, + [834] = 350, + [835] = 801, + [836] = 778, + [837] = 775, + [838] = 838, + [839] = 838, + [840] = 823, + [841] = 822, + [842] = 842, + [843] = 775, + [844] = 801, + [845] = 801, + [846] = 801, + [847] = 801, + [848] = 842, + [849] = 801, + [850] = 781, + [851] = 782, [852] = 852, - [853] = 853, - [854] = 854, - [855] = 855, - [856] = 856, - [857] = 857, - [858] = 858, - [859] = 859, - [860] = 860, - [861] = 861, - [862] = 862, - [863] = 863, - [864] = 864, + [853] = 800, + [854] = 778, + [855] = 801, + [856] = 13, + [857] = 342, + [858] = 302, + [859] = 464, + [860] = 485, + [861] = 303, + [862] = 367, + [863] = 367, + [864] = 13, [865] = 865, - [866] = 866, + [866] = 309, [867] = 867, - [868] = 868, - [869] = 869, + [868] = 299, + [869] = 323, [870] = 870, - [871] = 871, - [872] = 872, - [873] = 873, - [874] = 874, - [875] = 875, - [876] = 876, - [877] = 877, - [878] = 878, - [879] = 879, - [880] = 880, - [881] = 881, - [882] = 882, - [883] = 883, - [884] = 884, - [885] = 885, - [886] = 886, - [887] = 887, - [888] = 888, - [889] = 889, - [890] = 890, - [891] = 891, - [892] = 878, - [893] = 893, - [894] = 894, - [895] = 895, - [896] = 896, - [897] = 897, - [898] = 898, - [899] = 899, - [900] = 900, - [901] = 901, - [902] = 902, - [903] = 903, - [904] = 904, - [905] = 905, - [906] = 906, - [907] = 907, - [908] = 908, - [909] = 909, - [910] = 910, - [911] = 911, - [912] = 912, - [913] = 913, - [914] = 914, - [915] = 915, - [916] = 916, - [917] = 850, - [918] = 918, - [919] = 919, - [920] = 920, - [921] = 921, - [922] = 918, - [923] = 916, - [924] = 915, - [925] = 895, - [926] = 894, - [927] = 893, - [928] = 920, - [929] = 921, - [930] = 877, - [931] = 931, - [932] = 876, - [933] = 875, - [934] = 874, - [935] = 873, - [936] = 872, - [937] = 871, - [938] = 870, - [939] = 869, - [940] = 868, - [941] = 867, + [871] = 295, + [872] = 312, + [873] = 308, + [874] = 307, + [875] = 319, + [876] = 320, + [877] = 321, + [878] = 327, + [879] = 328, + [880] = 329, + [881] = 867, + [882] = 331, + [883] = 870, + [884] = 341, + [885] = 338, + [886] = 322, + [887] = 301, + [888] = 306, + [889] = 296, + [890] = 305, + [891] = 310, + [892] = 297, + [893] = 294, + [894] = 865, + [895] = 335, + [896] = 300, + [897] = 303, + [898] = 302, + [899] = 298, + [900] = 339, + [901] = 326, + [902] = 485, + [903] = 310, + [904] = 297, + [905] = 322, + [906] = 327, + [907] = 298, + [908] = 294, + [909] = 295, + [910] = 309, + [911] = 328, + [912] = 306, + [913] = 464, + [914] = 339, + [915] = 305, + [916] = 300, + [917] = 323, + [918] = 341, + [919] = 312, + [920] = 319, + [921] = 320, + [922] = 321, + [923] = 308, + [924] = 307, + [925] = 335, + [926] = 338, + [927] = 331, + [928] = 329, + [929] = 301, + [930] = 296, + [931] = 326, + [932] = 932, + [933] = 933, + [934] = 934, + [935] = 935, + [936] = 936, + [937] = 937, + [938] = 938, + [939] = 939, + [940] = 940, + [941] = 941, [942] = 942, - [943] = 866, - [944] = 865, - [945] = 864, - [946] = 863, - [947] = 862, - [948] = 861, - [949] = 860, + [943] = 943, + [944] = 944, + [945] = 945, + [946] = 946, + [947] = 947, + [948] = 948, + [949] = 949, [950] = 950, - [951] = 859, - [952] = 858, - [953] = 857, - [954] = 856, + [951] = 951, + [952] = 952, + [953] = 953, + [954] = 954, [955] = 955, - [956] = 855, + [956] = 956, [957] = 957, [958] = 958, - [959] = 854, - [960] = 853, - [961] = 852, - [962] = 942, - [963] = 851, - [964] = 879, - [965] = 880, - [966] = 881, - [967] = 882, - [968] = 883, - [969] = 884, - [970] = 885, - [971] = 886, - [972] = 887, - [973] = 888, - [974] = 889, - [975] = 890, - [976] = 891, - [977] = 896, + [959] = 959, + [960] = 960, + [961] = 961, + [962] = 962, + [963] = 963, + [964] = 932, + [965] = 965, + [966] = 966, + [967] = 967, + [968] = 968, + [969] = 969, + [970] = 970, + [971] = 971, + [972] = 972, + [973] = 933, + [974] = 974, + [975] = 975, + [976] = 976, + [977] = 977, [978] = 978, - [979] = 897, - [980] = 898, - [981] = 899, - [982] = 900, - [983] = 901, - [984] = 902, - [985] = 903, - [986] = 904, - [987] = 905, - [988] = 906, - [989] = 907, - [990] = 908, - [991] = 909, - [992] = 910, - [993] = 911, - [994] = 912, - [995] = 913, - [996] = 914, - [997] = 919, - [998] = 950, - [999] = 958, - [1000] = 955, - [1001] = 957, - [1002] = 931, - [1003] = 882, - [1004] = 885, - [1005] = 866, + [979] = 979, + [980] = 980, + [981] = 981, + [982] = 982, + [983] = 983, + [984] = 984, + [985] = 985, + [986] = 986, + [987] = 987, + [988] = 988, + [989] = 989, + [990] = 990, + [991] = 991, + [992] = 992, + [993] = 993, + [994] = 994, + [995] = 995, + [996] = 996, + [997] = 997, + [998] = 998, + [999] = 999, + [1000] = 1000, + [1001] = 1001, + [1002] = 1002, + [1003] = 1003, + [1004] = 1004, + [1005] = 1005, [1006] = 1006, [1007] = 1007, - [1008] = 897, - [1009] = 898, + [1008] = 1008, + [1009] = 1009, [1010] = 1010, - [1011] = 899, - [1012] = 900, - [1013] = 901, + [1011] = 1011, + [1012] = 933, + [1013] = 1013, [1014] = 1014, [1015] = 1015, [1016] = 1016, - [1017] = 1017, - [1018] = 1018, - [1019] = 1019, - [1020] = 1020, - [1021] = 1021, - [1022] = 1022, - [1023] = 1023, - [1024] = 1024, - [1025] = 1025, - [1026] = 1026, - [1027] = 1027, - [1028] = 1028, - [1029] = 865, - [1030] = 1030, - [1031] = 1031, - [1032] = 902, - [1033] = 1033, - [1034] = 1034, - [1035] = 1035, - [1036] = 1036, - [1037] = 1037, - [1038] = 1038, - [1039] = 1039, - [1040] = 1040, - [1041] = 1041, - [1042] = 867, - [1043] = 864, - [1044] = 1044, - [1045] = 1045, - [1046] = 863, - [1047] = 1047, - [1048] = 1048, - [1049] = 1049, - [1050] = 903, - [1051] = 1020, - [1052] = 1052, - [1053] = 862, - [1054] = 1054, - [1055] = 1055, - [1056] = 1056, - [1057] = 904, - [1058] = 1058, - [1059] = 1059, - [1060] = 861, - [1061] = 1061, - [1062] = 921, - [1063] = 1015, - [1064] = 860, - [1065] = 859, - [1066] = 858, - [1067] = 905, - [1068] = 1068, - [1069] = 1069, - [1070] = 1070, - [1071] = 1071, - [1072] = 868, - [1073] = 1073, - [1074] = 1074, - [1075] = 1016, - [1076] = 869, - [1077] = 1077, - [1078] = 1078, - [1079] = 1079, - [1080] = 906, - [1081] = 1081, - [1082] = 870, - [1083] = 1083, - [1084] = 1084, - [1085] = 1085, - [1086] = 871, - [1087] = 1087, - [1088] = 1088, - [1089] = 1089, - [1090] = 1090, - [1091] = 1091, - [1092] = 1092, - [1093] = 872, - [1094] = 907, - [1095] = 1095, - [1096] = 1096, - [1097] = 1020, - [1098] = 877, - [1099] = 1099, - [1100] = 876, - [1101] = 908, - [1102] = 894, - [1103] = 873, - [1104] = 1104, - [1105] = 1105, - [1106] = 857, - [1107] = 1107, + [1017] = 937, + [1018] = 938, + [1019] = 939, + [1020] = 940, + [1021] = 981, + [1022] = 935, + [1023] = 944, + [1024] = 945, + [1025] = 946, + [1026] = 947, + [1027] = 948, + [1028] = 949, + [1029] = 950, + [1030] = 951, + [1031] = 952, + [1032] = 953, + [1033] = 954, + [1034] = 955, + [1035] = 956, + [1036] = 957, + [1037] = 958, + [1038] = 959, + [1039] = 960, + [1040] = 961, + [1041] = 962, + [1042] = 963, + [1043] = 965, + [1044] = 966, + [1045] = 967, + [1046] = 968, + [1047] = 969, + [1048] = 970, + [1049] = 933, + [1050] = 971, + [1051] = 972, + [1052] = 974, + [1053] = 975, + [1054] = 976, + [1055] = 977, + [1056] = 981, + [1057] = 978, + [1058] = 979, + [1059] = 980, + [1060] = 982, + [1061] = 983, + [1062] = 984, + [1063] = 985, + [1064] = 986, + [1065] = 987, + [1066] = 988, + [1067] = 989, + [1068] = 990, + [1069] = 991, + [1070] = 992, + [1071] = 993, + [1072] = 994, + [1073] = 995, + [1074] = 996, + [1075] = 997, + [1076] = 998, + [1077] = 999, + [1078] = 1000, + [1079] = 1001, + [1080] = 1002, + [1081] = 1003, + [1082] = 1004, + [1083] = 1005, + [1084] = 933, + [1085] = 1006, + [1086] = 1007, + [1087] = 1008, + [1088] = 1009, + [1089] = 1010, + [1090] = 1011, + [1091] = 1013, + [1092] = 1014, + [1093] = 1015, + [1094] = 1016, + [1095] = 936, + [1096] = 981, + [1097] = 943, + [1098] = 981, + [1099] = 942, + [1100] = 934, + [1101] = 941, + [1102] = 1102, + [1103] = 985, + [1104] = 998, + [1105] = 938, + [1106] = 982, + [1107] = 1003, [1108] = 1108, - [1109] = 875, - [1110] = 856, - [1111] = 909, + [1109] = 1109, + [1110] = 939, + [1111] = 940, [1112] = 1112, - [1113] = 896, - [1114] = 855, - [1115] = 910, - [1116] = 1116, - [1117] = 1117, - [1118] = 1020, - [1119] = 854, - [1120] = 853, + [1113] = 1113, + [1114] = 1114, + [1115] = 1115, + [1116] = 1002, + [1117] = 1001, + [1118] = 1000, + [1119] = 1119, + [1120] = 944, [1121] = 1121, - [1122] = 911, - [1123] = 1123, + [1122] = 1122, + [1123] = 999, [1124] = 1124, - [1125] = 912, + [1125] = 980, [1126] = 1126, - [1127] = 1127, + [1127] = 999, [1128] = 1128, - [1129] = 1129, - [1130] = 913, - [1131] = 1131, - [1132] = 914, - [1133] = 1133, - [1134] = 1134, - [1135] = 850, - [1136] = 919, + [1129] = 1114, + [1130] = 1126, + [1131] = 945, + [1132] = 1113, + [1133] = 946, + [1134] = 976, + [1135] = 947, + [1136] = 1112, [1137] = 1137, - [1138] = 920, - [1139] = 1044, - [1140] = 1049, - [1141] = 1054, - [1142] = 1055, - [1143] = 1059, - [1144] = 852, - [1145] = 921, - [1146] = 1146, - [1147] = 874, - [1148] = 895, - [1149] = 851, - [1150] = 879, - [1151] = 880, - [1152] = 881, + [1138] = 998, + [1139] = 997, + [1140] = 1140, + [1141] = 1141, + [1142] = 1142, + [1143] = 996, + [1144] = 1144, + [1145] = 1145, + [1146] = 995, + [1147] = 994, + [1148] = 993, + [1149] = 1149, + [1150] = 1150, + [1151] = 948, + [1152] = 949, [1153] = 1153, - [1154] = 1154, - [1155] = 1155, + [1154] = 950, + [1155] = 951, [1156] = 1156, [1157] = 1157, - [1158] = 918, + [1158] = 1102, [1159] = 1159, - [1160] = 916, - [1161] = 915, + [1160] = 1160, + [1161] = 1161, [1162] = 1162, [1163] = 1163, [1164] = 1164, [1165] = 1165, - [1166] = 1166, - [1167] = 1167, + [1166] = 970, + [1167] = 1122, [1168] = 1168, - [1169] = 1169, - [1170] = 1170, + [1169] = 1121, + [1170] = 1119, [1171] = 1171, - [1172] = 1015, + [1172] = 1000, [1173] = 1173, - [1174] = 1174, - [1175] = 878, + [1174] = 978, + [1175] = 1175, [1176] = 1176, [1177] = 1177, [1178] = 1178, - [1179] = 1179, - [1180] = 883, - [1181] = 1181, + [1179] = 1001, + [1180] = 1002, + [1181] = 1115, [1182] = 1182, - [1183] = 1183, - [1184] = 918, - [1185] = 895, - [1186] = 1134, - [1187] = 1108, - [1188] = 894, - [1189] = 893, - [1190] = 878, - [1191] = 1146, - [1192] = 1116, - [1193] = 1007, + [1183] = 992, + [1184] = 1108, + [1185] = 991, + [1186] = 1186, + [1187] = 1187, + [1188] = 990, + [1189] = 1189, + [1190] = 1003, + [1191] = 1191, + [1192] = 1192, + [1193] = 1193, [1194] = 1194, - [1195] = 884, - [1196] = 891, - [1197] = 885, - [1198] = 886, - [1199] = 887, - [1200] = 893, - [1201] = 888, - [1202] = 889, + [1195] = 952, + [1196] = 1196, + [1197] = 1197, + [1198] = 1177, + [1199] = 1199, + [1200] = 1200, + [1201] = 1201, + [1202] = 1202, [1203] = 1203, - [1204] = 1137, - [1205] = 1083, - [1206] = 1015, - [1207] = 1207, - [1208] = 920, - [1209] = 919, - [1210] = 1019, - [1211] = 1028, - [1212] = 1052, - [1213] = 1092, - [1214] = 850, - [1215] = 914, - [1216] = 913, - [1217] = 912, - [1218] = 877, - [1219] = 876, - [1220] = 875, - [1221] = 874, - [1222] = 1156, - [1223] = 1163, - [1224] = 911, - [1225] = 910, - [1226] = 1170, - [1227] = 1227, - [1228] = 1227, + [1204] = 989, + [1205] = 953, + [1206] = 954, + [1207] = 955, + [1208] = 956, + [1209] = 957, + [1210] = 1210, + [1211] = 958, + [1212] = 1212, + [1213] = 1213, + [1214] = 988, + [1215] = 987, + [1216] = 1216, + [1217] = 1217, + [1218] = 1218, + [1219] = 1219, + [1220] = 1220, + [1221] = 1221, + [1222] = 986, + [1223] = 1223, + [1224] = 1224, + [1225] = 1225, + [1226] = 985, + [1227] = 984, + [1228] = 983, [1229] = 1229, [1230] = 1230, - [1231] = 909, + [1231] = 959, [1232] = 1232, [1233] = 1233, [1234] = 1234, [1235] = 1235, - [1236] = 890, - [1237] = 1107, - [1238] = 908, - [1239] = 1099, - [1240] = 907, - [1241] = 1194, - [1242] = 1183, - [1243] = 1171, - [1244] = 873, - [1245] = 1088, - [1246] = 1087, - [1247] = 1229, - [1248] = 1117, - [1249] = 1112, - [1250] = 906, - [1251] = 1159, - [1252] = 1015, - [1253] = 872, - [1254] = 871, - [1255] = 870, - [1256] = 869, - [1257] = 868, - [1258] = 1068, - [1259] = 1056, - [1260] = 867, - [1261] = 1230, - [1262] = 1041, - [1263] = 1040, - [1264] = 1038, - [1265] = 1037, - [1266] = 1034, - [1267] = 1033, - [1268] = 1031, - [1269] = 1036, - [1270] = 1030, - [1271] = 1018, - [1272] = 866, - [1273] = 1024, - [1274] = 1079, - [1275] = 1078, + [1236] = 1236, + [1237] = 1237, + [1238] = 1238, + [1239] = 1239, + [1240] = 996, + [1241] = 1182, + [1242] = 1203, + [1243] = 1004, + [1244] = 1244, + [1245] = 977, + [1246] = 995, + [1247] = 994, + [1248] = 1248, + [1249] = 1249, + [1250] = 1250, + [1251] = 1251, + [1252] = 982, + [1253] = 980, + [1254] = 979, + [1255] = 978, + [1256] = 977, + [1257] = 1005, + [1258] = 993, + [1259] = 976, + [1260] = 1004, + [1261] = 1149, + [1262] = 1262, + [1263] = 1250, + [1264] = 1153, + [1265] = 1156, + [1266] = 975, + [1267] = 1267, + [1268] = 1159, + [1269] = 1269, + [1270] = 1270, + [1271] = 1271, + [1272] = 1160, + [1273] = 1162, + [1274] = 1274, + [1275] = 1275, [1276] = 1276, - [1277] = 1074, - [1278] = 916, + [1277] = 1277, + [1278] = 1278, [1279] = 1279, - [1280] = 1026, - [1281] = 1027, - [1282] = 1006, - [1283] = 1010, - [1284] = 1017, - [1285] = 1025, - [1286] = 865, - [1287] = 915, - [1288] = 1073, - [1289] = 905, - [1290] = 1035, - [1291] = 1232, + [1280] = 971, + [1281] = 1251, + [1282] = 1005, + [1283] = 972, + [1284] = 1262, + [1285] = 1285, + [1286] = 974, + [1287] = 972, + [1288] = 971, + [1289] = 970, + [1290] = 969, + [1291] = 1291, [1292] = 1292, - [1293] = 1061, + [1293] = 1006, [1294] = 1294, - [1295] = 864, - [1296] = 863, - [1297] = 862, - [1298] = 861, - [1299] = 860, - [1300] = 859, - [1301] = 858, - [1302] = 1069, - [1303] = 1070, - [1304] = 1071, - [1305] = 1077, - [1306] = 1081, - [1307] = 1084, - [1308] = 1085, - [1309] = 1089, - [1310] = 1090, - [1311] = 1091, - [1312] = 1095, - [1313] = 1096, - [1314] = 1104, - [1315] = 1105, - [1316] = 857, - [1317] = 856, - [1318] = 855, - [1319] = 854, - [1320] = 853, - [1321] = 1121, - [1322] = 1058, - [1323] = 904, - [1324] = 1324, - [1325] = 903, - [1326] = 1048, - [1327] = 1123, - [1328] = 1124, - [1329] = 1126, - [1330] = 1127, - [1331] = 1128, - [1332] = 1129, - [1333] = 1131, - [1334] = 1233, - [1335] = 1133, - [1336] = 1207, - [1337] = 852, - [1338] = 1047, - [1339] = 1234, - [1340] = 851, - [1341] = 879, - [1342] = 880, - [1343] = 881, - [1344] = 882, - [1345] = 1154, - [1346] = 1155, - [1347] = 1162, - [1348] = 1165, - [1349] = 1166, - [1350] = 1167, - [1351] = 1168, - [1352] = 1176, - [1353] = 1177, - [1354] = 1178, - [1355] = 1179, - [1356] = 883, - [1357] = 884, - [1358] = 1045, - [1359] = 886, - [1360] = 887, - [1361] = 888, - [1362] = 889, - [1363] = 1363, - [1364] = 1203, - [1365] = 1363, - [1366] = 1324, - [1367] = 1294, - [1368] = 1292, - [1369] = 1279, - [1370] = 1276, - [1371] = 890, - [1372] = 891, - [1373] = 1020, - [1374] = 1235, - [1375] = 1182, - [1376] = 1181, - [1377] = 1039, - [1378] = 1174, - [1379] = 1173, - [1380] = 1169, - [1381] = 1164, - [1382] = 1157, - [1383] = 1153, - [1384] = 896, - [1385] = 897, - [1386] = 898, - [1387] = 899, - [1388] = 900, - [1389] = 901, - [1390] = 1014, - [1391] = 1021, - [1392] = 1022, - [1393] = 1023, - [1394] = 902, - [1395] = 1395, - [1396] = 1396, - [1397] = 1397, - [1398] = 1398, - [1399] = 1396, - [1400] = 1398, - [1401] = 1401, - [1402] = 1396, - [1403] = 1403, - [1404] = 1404, - [1405] = 1405, - [1406] = 1398, - [1407] = 1396, - [1408] = 1398, - [1409] = 1398, - [1410] = 1396, - [1411] = 1411, - [1412] = 1412, - [1413] = 1413, - [1414] = 1413, - [1415] = 1415, - [1416] = 1416, - [1417] = 1416, - [1418] = 1413, - [1419] = 1413, - [1420] = 1411, - [1421] = 1415, - [1422] = 1411, - [1423] = 1411, - [1424] = 1416, - [1425] = 1415, - [1426] = 1415, - [1427] = 1413, - [1428] = 1416, - [1429] = 1415, - [1430] = 1416, - [1431] = 1411, - [1432] = 1432, - [1433] = 1433, - [1434] = 1434, - [1435] = 1432, - [1436] = 1434, - [1437] = 1437, - [1438] = 1438, - [1439] = 1439, - [1440] = 1440, - [1441] = 1441, - [1442] = 1442, - [1443] = 1437, - [1444] = 1441, - [1445] = 1445, - [1446] = 1438, - [1447] = 1447, - [1448] = 1448, - [1449] = 1449, - [1450] = 1450, - [1451] = 1451, - [1452] = 1452, - [1453] = 1453, - [1454] = 1454, - [1455] = 1455, - [1456] = 1448, - [1457] = 1451, - [1458] = 1451, - [1459] = 1448, - [1460] = 1460, - [1461] = 1454, - [1462] = 1462, - [1463] = 1463, - [1464] = 1462, - [1465] = 1447, - [1466] = 1451, - [1467] = 1448, - [1468] = 1448, - [1469] = 1469, - [1470] = 1455, - [1471] = 1447, - [1472] = 1449, - [1473] = 1450, - [1474] = 1450, - [1475] = 1460, - [1476] = 1452, + [1295] = 979, + [1296] = 1296, + [1297] = 1297, + [1298] = 1168, + [1299] = 1299, + [1300] = 1300, + [1301] = 1173, + [1302] = 1302, + [1303] = 1007, + [1304] = 1304, + [1305] = 1305, + [1306] = 992, + [1307] = 991, + [1308] = 1308, + [1309] = 1309, + [1310] = 1310, + [1311] = 1311, + [1312] = 968, + [1313] = 967, + [1314] = 966, + [1315] = 965, + [1316] = 932, + [1317] = 963, + [1318] = 1318, + [1319] = 962, + [1320] = 960, + [1321] = 961, + [1322] = 1006, + [1323] = 1299, + [1324] = 974, + [1325] = 990, + [1326] = 1326, + [1327] = 1326, + [1328] = 1008, + [1329] = 1007, + [1330] = 961, + [1331] = 962, + [1332] = 963, + [1333] = 1008, + [1334] = 1009, + [1335] = 1009, + [1336] = 960, + [1337] = 932, + [1338] = 965, + [1339] = 966, + [1340] = 967, + [1341] = 968, + [1342] = 1311, + [1343] = 1300, + [1344] = 1310, + [1345] = 1238, + [1346] = 1189, + [1347] = 1237, + [1348] = 1236, + [1349] = 1191, + [1350] = 1192, + [1351] = 1194, + [1352] = 1010, + [1353] = 1235, + [1354] = 1234, + [1355] = 1197, + [1356] = 1285, + [1357] = 1011, + [1358] = 1010, + [1359] = 1011, + [1360] = 1199, + [1361] = 1013, + [1362] = 1014, + [1363] = 1233, + [1364] = 959, + [1365] = 1225, + [1366] = 1200, + [1367] = 1224, + [1368] = 1223, + [1369] = 1221, + [1370] = 1013, + [1371] = 989, + [1372] = 1220, + [1373] = 1014, + [1374] = 988, + [1375] = 987, + [1376] = 986, + [1377] = 1219, + [1378] = 997, + [1379] = 1218, + [1380] = 984, + [1381] = 1015, + [1382] = 1217, + [1383] = 1216, + [1384] = 1213, + [1385] = 1016, + [1386] = 1212, + [1387] = 1387, + [1388] = 1388, + [1389] = 1389, + [1390] = 1390, + [1391] = 1391, + [1392] = 1015, + [1393] = 937, + [1394] = 958, + [1395] = 1210, + [1396] = 983, + [1397] = 1229, + [1398] = 957, + [1399] = 956, + [1400] = 955, + [1401] = 954, + [1402] = 1402, + [1403] = 1230, + [1404] = 953, + [1405] = 1232, + [1406] = 1016, + [1407] = 938, + [1408] = 1109, + [1409] = 939, + [1410] = 940, + [1411] = 1239, + [1412] = 1387, + [1413] = 1202, + [1414] = 975, + [1415] = 1201, + [1416] = 1388, + [1417] = 969, + [1418] = 952, + [1419] = 1193, + [1420] = 1187, + [1421] = 1244, + [1422] = 1186, + [1423] = 1309, + [1424] = 1279, + [1425] = 1389, + [1426] = 1267, + [1427] = 1278, + [1428] = 1390, + [1429] = 1248, + [1430] = 1269, + [1431] = 1277, + [1432] = 1249, + [1433] = 1178, + [1434] = 944, + [1435] = 1124, + [1436] = 1128, + [1437] = 945, + [1438] = 946, + [1439] = 947, + [1440] = 1137, + [1441] = 1140, + [1442] = 1141, + [1443] = 1270, + [1444] = 1176, + [1445] = 1271, + [1446] = 1175, + [1447] = 1274, + [1448] = 1171, + [1449] = 1165, + [1450] = 1308, + [1451] = 1305, + [1452] = 1164, + [1453] = 1291, + [1454] = 1163, + [1455] = 1292, + [1456] = 1304, + [1457] = 1302, + [1458] = 1297, + [1459] = 1142, + [1460] = 1144, + [1461] = 1145, + [1462] = 1150, + [1463] = 1402, + [1464] = 937, + [1465] = 1275, + [1466] = 1391, + [1467] = 948, + [1468] = 949, + [1469] = 950, + [1470] = 951, + [1471] = 1157, + [1472] = 1276, + [1473] = 1296, + [1474] = 1196, + [1475] = 1294, + [1476] = 1476, [1477] = 1477, - [1478] = 1469, - [1479] = 1447, - [1480] = 1449, - [1481] = 1477, - [1482] = 1460, - [1483] = 1453, - [1484] = 1462, - [1485] = 1447, - [1486] = 1477, - [1487] = 1452, + [1478] = 1476, + [1479] = 1476, + [1480] = 1477, + [1481] = 1481, + [1482] = 1476, + [1483] = 1481, + [1484] = 1476, + [1485] = 1481, + [1486] = 1481, + [1487] = 1481, [1488] = 1488, - [1489] = 1477, - [1490] = 1450, - [1491] = 1455, - [1492] = 1463, - [1493] = 1455, - [1494] = 1454, - [1495] = 1454, - [1496] = 1463, - [1497] = 1462, - [1498] = 1462, - [1499] = 1469, - [1500] = 1453, - [1501] = 1460, - [1502] = 1454, - [1503] = 1449, - [1504] = 1449, - [1505] = 1463, - [1506] = 1469, - [1507] = 1453, - [1508] = 1477, - [1509] = 1460, - [1510] = 1463, - [1511] = 1451, - [1512] = 1453, - [1513] = 1450, - [1514] = 1452, - [1515] = 1455, - [1516] = 1469, - [1517] = 1452, - [1518] = 1488, - [1519] = 1519, - [1520] = 1520, + [1489] = 1489, + [1490] = 1490, + [1491] = 1490, + [1492] = 1492, + [1493] = 1490, + [1494] = 1489, + [1495] = 1495, + [1496] = 1489, + [1497] = 1490, + [1498] = 1489, + [1499] = 1489, + [1500] = 1500, + [1501] = 1501, + [1502] = 1490, + [1503] = 1503, + [1504] = 1504, + [1505] = 1505, + [1506] = 1506, + [1507] = 1507, + [1508] = 1508, + [1509] = 1509, + [1510] = 1510, + [1511] = 1511, + [1512] = 1506, + [1513] = 1513, + [1514] = 1514, + [1515] = 1513, + [1516] = 1516, + [1517] = 1517, + [1518] = 1518, + [1519] = 1517, + [1520] = 1510, [1521] = 1521, [1522] = 1522, [1523] = 1523, - [1524] = 1520, + [1524] = 1524, [1525] = 1525, [1526] = 1526, - [1527] = 1527, - [1528] = 1528, - [1529] = 1529, - [1530] = 1522, + [1527] = 1523, + [1528] = 1506, + [1529] = 1510, + [1530] = 1530, [1531] = 1531, - [1532] = 1532, - [1533] = 1533, - [1534] = 1534, - [1535] = 1535, - [1536] = 1536, - [1537] = 1537, - [1538] = 1538, - [1539] = 1534, - [1540] = 1540, - [1541] = 1540, - [1542] = 1535, - [1543] = 1543, - [1544] = 1544, + [1532] = 1516, + [1533] = 1523, + [1534] = 1510, + [1535] = 1517, + [1536] = 1506, + [1537] = 1523, + [1538] = 1524, + [1539] = 1525, + [1540] = 1517, + [1541] = 1506, + [1542] = 1510, + [1543] = 1517, + [1544] = 1523, [1545] = 1545, - [1546] = 1545, - [1547] = 1545, - [1548] = 1543, + [1546] = 1546, + [1547] = 1547, + [1548] = 1547, [1549] = 1549, - [1550] = 1544, + [1550] = 1550, [1551] = 1551, - [1552] = 1551, - [1553] = 1543, - [1554] = 1545, - [1555] = 1549, - [1556] = 1543, - [1557] = 1551, - [1558] = 1549, - [1559] = 1543, - [1560] = 1560, - [1561] = 1551, - [1562] = 1549, - [1563] = 1549, - [1564] = 1545, - [1565] = 1551, + [1552] = 1552, + [1553] = 1553, + [1554] = 1554, + [1555] = 1550, + [1556] = 1556, + [1557] = 1557, + [1558] = 1558, + [1559] = 1559, + [1560] = 1551, + [1561] = 1550, + [1562] = 1562, + [1563] = 1558, + [1564] = 1564, + [1565] = 1549, [1566] = 1566, - [1567] = 1567, + [1567] = 1557, [1568] = 1568, - [1569] = 1569, - [1570] = 1570, - [1571] = 1571, - [1572] = 1570, - [1573] = 1573, - [1574] = 1567, - [1575] = 1575, - [1576] = 1576, - [1577] = 1577, - [1578] = 1578, - [1579] = 1579, - [1580] = 1580, - [1581] = 1581, - [1582] = 1582, - [1583] = 1578, - [1584] = 1579, - [1585] = 1585, - [1586] = 1585, - [1587] = 1587, - [1588] = 1588, - [1589] = 1589, - [1590] = 1590, - [1591] = 1591, - [1592] = 276, - [1593] = 1593, - [1594] = 1594, - [1595] = 275, - [1596] = 1596, - [1597] = 1597, - [1598] = 1598, - [1599] = 1599, - [1600] = 1600, - [1601] = 1601, - [1602] = 1590, - [1603] = 1601, - [1604] = 1598, - [1605] = 1605, - [1606] = 1599, - [1607] = 1588, - [1608] = 1591, - [1609] = 1566, - [1610] = 1589, - [1611] = 1611, - [1612] = 1612, - [1613] = 1613, - [1614] = 1614, - [1615] = 1615, - [1616] = 1616, - [1617] = 1611, - [1618] = 1618, - [1619] = 1619, - [1620] = 1620, - [1621] = 1619, - [1622] = 1619, + [1569] = 1552, + [1570] = 1509, + [1571] = 1553, + [1572] = 1552, + [1573] = 1553, + [1574] = 1554, + [1575] = 1556, + [1576] = 1568, + [1577] = 1557, + [1578] = 1559, + [1579] = 1551, + [1580] = 1550, + [1581] = 1562, + [1582] = 1562, + [1583] = 1559, + [1584] = 1558, + [1585] = 1564, + [1586] = 1564, + [1587] = 1549, + [1588] = 1568, + [1589] = 1566, + [1590] = 1549, + [1591] = 1566, + [1592] = 1550, + [1593] = 1564, + [1594] = 1568, + [1595] = 1558, + [1596] = 1556, + [1597] = 1552, + [1598] = 1551, + [1599] = 1562, + [1600] = 1549, + [1601] = 1562, + [1602] = 1568, + [1603] = 1559, + [1604] = 1551, + [1605] = 1558, + [1606] = 1566, + [1607] = 1554, + [1608] = 1566, + [1609] = 1557, + [1610] = 1610, + [1611] = 1559, + [1612] = 1564, + [1613] = 1557, + [1614] = 1556, + [1615] = 1552, + [1616] = 1556, + [1617] = 1554, + [1618] = 1554, + [1619] = 1553, + [1620] = 1610, + [1621] = 1553, + [1622] = 1622, [1623] = 1623, [1624] = 1624, [1625] = 1625, - [1626] = 1611, - [1627] = 1619, - [1628] = 1613, + [1626] = 1624, + [1627] = 1627, + [1628] = 1628, [1629] = 1629, [1630] = 1630, [1631] = 1631, - [1632] = 1632, - [1633] = 1631, - [1634] = 1625, - [1635] = 1625, - [1636] = 1625, + [1632] = 1628, + [1633] = 1633, + [1634] = 1634, + [1635] = 1635, + [1636] = 1636, [1637] = 1637, [1638] = 1638, - [1639] = 1619, - [1640] = 1632, + [1639] = 1639, + [1640] = 1640, [1641] = 1641, [1642] = 1642, - [1643] = 277, - [1644] = 1613, - [1645] = 1642, - [1646] = 1613, - [1647] = 1631, + [1643] = 1643, + [1644] = 1644, + [1645] = 1645, + [1646] = 1641, + [1647] = 1647, [1648] = 1648, - [1649] = 1631, - [1650] = 1632, - [1651] = 1612, - [1652] = 1630, - [1653] = 1613, + [1649] = 1649, + [1650] = 1645, + [1651] = 1648, + [1652] = 1647, + [1653] = 1653, [1654] = 1654, - [1655] = 1616, - [1656] = 1629, - [1657] = 1616, - [1658] = 1616, + [1655] = 1655, + [1656] = 1656, + [1657] = 1657, + [1658] = 1653, [1659] = 1659, - [1660] = 1611, - [1661] = 1654, - [1662] = 1619, - [1663] = 1659, - [1664] = 1632, - [1665] = 1612, - [1666] = 1612, - [1667] = 1659, + [1660] = 1655, + [1661] = 1655, + [1662] = 1662, + [1663] = 1663, + [1664] = 1655, + [1665] = 1665, + [1666] = 1659, + [1667] = 1656, [1668] = 1668, - [1669] = 1632, - [1670] = 1625, - [1671] = 1616, - [1672] = 1672, - [1673] = 1611, - [1674] = 1629, - [1675] = 1642, - [1676] = 1637, - [1677] = 1618, - [1678] = 1659, - [1679] = 1642, - [1680] = 1629, + [1669] = 1655, + [1670] = 1656, + [1671] = 1653, + [1672] = 1656, + [1673] = 1673, + [1674] = 1653, + [1675] = 1675, + [1676] = 1653, + [1677] = 1659, + [1678] = 1678, + [1679] = 1656, + [1680] = 1659, [1681] = 1659, - [1682] = 1682, - [1683] = 1619, - [1684] = 1684, - [1685] = 1612, - [1686] = 1642, + [1682] = 1653, + [1683] = 1659, + [1684] = 1655, + [1685] = 1656, + [1686] = 1686, [1687] = 1687, [1688] = 1688, - [1689] = 1619, - [1690] = 1629, - [1691] = 1631, - [1692] = 1615, + [1689] = 1657, + [1690] = 1687, + [1691] = 1691, + [1692] = 1692, [1693] = 1693, [1694] = 1694, [1695] = 1695, - [1696] = 1695, + [1696] = 1696, [1697] = 1697, [1698] = 1698, [1699] = 1699, - [1700] = 1695, - [1701] = 1695, - [1702] = 275, - [1703] = 298, - [1704] = 1704, + [1700] = 1700, + [1701] = 1701, + [1702] = 1702, + [1703] = 1703, + [1704] = 1700, [1705] = 1705, - [1706] = 276, - [1707] = 1695, + [1706] = 1706, + [1707] = 1702, [1708] = 1708, - [1709] = 1709, - [1710] = 1710, + [1709] = 1696, + [1710] = 1706, [1711] = 1711, - [1712] = 304, - [1713] = 1695, - [1714] = 1704, + [1712] = 1712, + [1713] = 1713, + [1714] = 1714, [1715] = 1715, [1716] = 1716, [1717] = 1717, @@ -4591,228 +4820,228 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1721] = 1721, [1722] = 1722, [1723] = 1723, - [1724] = 277, + [1724] = 1724, [1725] = 1725, [1726] = 1726, - [1727] = 1727, - [1728] = 1727, - [1729] = 1638, + [1727] = 1716, + [1728] = 1728, + [1729] = 1716, [1730] = 1730, [1731] = 1731, - [1732] = 1732, - [1733] = 1733, + [1732] = 1716, + [1733] = 1731, [1734] = 1734, [1735] = 1735, [1736] = 1736, [1737] = 1737, [1738] = 1738, [1739] = 1739, - [1740] = 1740, - [1741] = 1730, + [1740] = 1731, + [1741] = 1741, [1742] = 1742, - [1743] = 1720, - [1744] = 1721, - [1745] = 1726, + [1743] = 1743, + [1744] = 1744, + [1745] = 1745, [1746] = 1746, - [1747] = 1735, + [1747] = 1747, [1748] = 1748, [1749] = 1749, - [1750] = 1736, - [1751] = 1742, - [1752] = 1740, - [1753] = 1719, + [1750] = 1750, + [1751] = 1751, + [1752] = 1752, + [1753] = 1753, [1754] = 1754, [1755] = 1755, - [1756] = 1716, + [1756] = 1756, [1757] = 1757, - [1758] = 1758, - [1759] = 1722, + [1758] = 2, + [1759] = 1759, [1760] = 1760, - [1761] = 1746, - [1762] = 1748, - [1763] = 1734, - [1764] = 1737, - [1765] = 1738, - [1766] = 1725, - [1767] = 1715, - [1768] = 1749, - [1769] = 1739, - [1770] = 1758, - [1771] = 1757, + [1761] = 1761, + [1762] = 1731, + [1763] = 1763, + [1764] = 3, + [1765] = 1716, + [1766] = 1766, + [1767] = 1731, + [1768] = 1768, + [1769] = 1769, + [1770] = 1770, + [1771] = 1771, [1772] = 1772, - [1773] = 1773, - [1774] = 1755, + [1773] = 1771, + [1774] = 13, [1775] = 1775, [1776] = 1776, [1777] = 1777, - [1778] = 1778, + [1778] = 1693, [1779] = 1779, - [1780] = 1780, + [1780] = 1771, [1781] = 1781, [1782] = 1782, [1783] = 1783, - [1784] = 1783, - [1785] = 1785, - [1786] = 1780, - [1787] = 304, - [1788] = 1788, - [1789] = 1775, - [1790] = 1790, - [1791] = 1782, + [1784] = 1775, + [1785] = 1781, + [1786] = 1782, + [1787] = 1783, + [1788] = 1770, + [1789] = 1772, + [1790] = 3, + [1791] = 1775, [1792] = 1792, - [1793] = 1793, - [1794] = 1777, + [1793] = 1781, + [1794] = 1782, [1795] = 1795, - [1796] = 1776, - [1797] = 1778, - [1798] = 1785, - [1799] = 298, - [1800] = 1699, - [1801] = 1788, + [1796] = 2, + [1797] = 1797, + [1798] = 1798, + [1799] = 1799, + [1800] = 1797, + [1801] = 1801, [1802] = 1802, [1803] = 1803, [1804] = 1804, [1805] = 1805, - [1806] = 1805, + [1806] = 1806, [1807] = 1807, [1808] = 1808, [1809] = 1809, - [1810] = 1810, - [1811] = 1811, - [1812] = 1809, + [1810] = 1809, + [1811] = 1797, + [1812] = 1804, [1813] = 1808, - [1814] = 1814, - [1815] = 1815, - [1816] = 1816, - [1817] = 1817, - [1818] = 1818, - [1819] = 1805, - [1820] = 1808, + [1814] = 1806, + [1815] = 1803, + [1816] = 299, + [1817] = 1803, + [1818] = 1808, + [1819] = 1819, + [1820] = 1820, [1821] = 1821, - [1822] = 1805, - [1823] = 1805, - [1824] = 1824, - [1825] = 1814, - [1826] = 1824, - [1827] = 1808, + [1822] = 1801, + [1823] = 1797, + [1824] = 1797, + [1825] = 1825, + [1826] = 1806, + [1827] = 1820, [1828] = 1828, [1829] = 1829, [1830] = 1830, [1831] = 1831, - [1832] = 1808, + [1832] = 1819, [1833] = 1833, [1834] = 1834, - [1835] = 1831, + [1835] = 1835, [1836] = 1836, - [1837] = 1837, - [1838] = 1838, - [1839] = 1839, + [1837] = 1799, + [1838] = 1825, + [1839] = 1799, [1840] = 1840, - [1841] = 1841, - [1842] = 1842, - [1843] = 1843, - [1844] = 1844, - [1845] = 1845, - [1846] = 1846, + [1841] = 1797, + [1842] = 1804, + [1843] = 1809, + [1844] = 1808, + [1845] = 1797, + [1846] = 13, [1847] = 1847, - [1848] = 1848, - [1849] = 1849, - [1850] = 1850, - [1851] = 1847, - [1852] = 1847, - [1853] = 1853, - [1854] = 1854, + [1848] = 1797, + [1849] = 1820, + [1850] = 1797, + [1851] = 1804, + [1852] = 1833, + [1853] = 1829, + [1854] = 1809, [1855] = 1855, - [1856] = 1856, - [1857] = 1855, - [1858] = 1855, - [1859] = 1859, + [1856] = 1808, + [1857] = 1857, + [1858] = 1806, + [1859] = 1833, [1860] = 1860, - [1861] = 1860, - [1862] = 1849, - [1863] = 1863, - [1864] = 1864, - [1865] = 1865, - [1866] = 1855, - [1867] = 1867, - [1868] = 1845, - [1869] = 1847, - [1870] = 1842, - [1871] = 1853, - [1872] = 1859, - [1873] = 1840, - [1874] = 1874, - [1875] = 1875, - [1876] = 1844, - [1877] = 1849, + [1861] = 1809, + [1862] = 1803, + [1863] = 1806, + [1864] = 1801, + [1865] = 1840, + [1866] = 1819, + [1867] = 1799, + [1868] = 1819, + [1869] = 1801, + [1870] = 1805, + [1871] = 1803, + [1872] = 1872, + [1873] = 1819, + [1874] = 1833, + [1875] = 1857, + [1876] = 1876, + [1877] = 1804, [1878] = 1878, - [1879] = 1879, - [1880] = 1837, - [1881] = 1839, - [1882] = 1848, - [1883] = 1883, - [1884] = 1883, - [1885] = 1863, - [1886] = 1879, + [1879] = 1820, + [1880] = 1833, + [1881] = 1881, + [1882] = 1820, + [1883] = 1801, + [1884] = 1799, + [1885] = 1798, + [1886] = 1830, [1887] = 1887, - [1888] = 1875, - [1889] = 1874, - [1890] = 1863, - [1891] = 1842, - [1892] = 1840, - [1893] = 1893, - [1894] = 1894, - [1895] = 1839, + [1888] = 1888, + [1889] = 1889, + [1890] = 1890, + [1891] = 1891, + [1892] = 1892, + [1893] = 302, + [1894] = 1891, + [1895] = 1890, [1896] = 1896, - [1897] = 1856, - [1898] = 1860, - [1899] = 1842, - [1900] = 1863, - [1901] = 1846, - [1902] = 1841, - [1903] = 1849, - [1904] = 1840, - [1905] = 1864, - [1906] = 1848, - [1907] = 1867, - [1908] = 1848, - [1909] = 1850, - [1910] = 1910, - [1911] = 1911, - [1912] = 1847, - [1913] = 1849, - [1914] = 1914, - [1915] = 1843, - [1916] = 1914, - [1917] = 1840, - [1918] = 1837, - [1919] = 1842, + [1897] = 1897, + [1898] = 1896, + [1899] = 1899, + [1900] = 1900, + [1901] = 1890, + [1902] = 300, + [1903] = 1889, + [1904] = 1904, + [1905] = 1888, + [1906] = 1906, + [1907] = 1907, + [1908] = 1908, + [1909] = 1888, + [1910] = 1887, + [1911] = 1896, + [1912] = 1889, + [1913] = 1887, + [1914] = 1896, + [1915] = 1915, + [1916] = 1916, + [1917] = 1891, + [1918] = 1891, + [1919] = 1889, [1920] = 1920, - [1921] = 1841, - [1922] = 1922, - [1923] = 1923, - [1924] = 1848, - [1925] = 1925, - [1926] = 1860, - [1927] = 1860, - [1928] = 1920, + [1921] = 303, + [1922] = 1896, + [1923] = 1890, + [1924] = 1890, + [1925] = 1889, + [1926] = 1891, + [1927] = 1896, + [1928] = 2, [1929] = 1929, - [1930] = 1930, - [1931] = 1837, - [1932] = 1910, - [1933] = 1855, - [1934] = 1883, - [1935] = 1838, - [1936] = 1841, - [1937] = 1896, - [1938] = 1883, - [1939] = 1839, - [1940] = 1883, - [1941] = 1841, - [1942] = 1839, - [1943] = 1837, - [1944] = 1911, - [1945] = 1863, + [1930] = 1888, + [1931] = 1887, + [1932] = 301, + [1933] = 1896, + [1934] = 3, + [1935] = 1899, + [1936] = 1916, + [1937] = 1900, + [1938] = 1887, + [1939] = 1939, + [1940] = 1940, + [1941] = 1888, + [1942] = 1942, + [1943] = 1896, + [1944] = 1944, + [1945] = 1945, [1946] = 1946, [1947] = 1947, [1948] = 1948, @@ -4822,666 +5051,666 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [1952] = 1952, [1953] = 1953, [1954] = 1954, - [1955] = 1951, - [1956] = 1948, + [1955] = 1955, + [1956] = 1956, [1957] = 1957, - [1958] = 1947, - [1959] = 1950, - [1960] = 1948, + [1958] = 1958, + [1959] = 1957, + [1960] = 1960, [1961] = 1961, [1962] = 1962, - [1963] = 1963, + [1963] = 1951, [1964] = 1964, - [1965] = 1964, + [1965] = 1965, [1966] = 1966, [1967] = 1967, - [1968] = 1951, - [1969] = 1950, + [1968] = 1968, + [1969] = 1969, [1970] = 1970, - [1971] = 1971, + [1971] = 1964, [1972] = 1972, - [1973] = 1973, + [1973] = 1965, [1974] = 1974, - [1975] = 1954, + [1975] = 1975, [1976] = 1976, - [1977] = 1964, - [1978] = 1966, - [1979] = 1973, - [1980] = 1954, + [1977] = 1977, + [1978] = 1978, + [1979] = 1979, + [1980] = 1967, [1981] = 1981, - [1982] = 1964, - [1983] = 1957, - [1984] = 1984, - [1985] = 1985, - [1986] = 1972, + [1982] = 1982, + [1983] = 1958, + [1984] = 1950, + [1985] = 13, + [1986] = 1944, [1987] = 1987, [1988] = 1988, - [1989] = 1989, - [1990] = 1948, - [1991] = 1950, - [1992] = 1992, - [1993] = 1993, - [1994] = 1994, - [1995] = 1971, - [1996] = 1973, - [1997] = 1950, - [1998] = 1957, - [1999] = 1985, - [2000] = 1972, - [2001] = 1971, - [2002] = 2002, + [1989] = 1982, + [1990] = 1981, + [1991] = 1991, + [1992] = 1978, + [1993] = 1847, + [1994] = 1991, + [1995] = 1949, + [1996] = 1996, + [1997] = 1997, + [1998] = 1956, + [1999] = 1999, + [2000] = 1948, + [2001] = 1947, + [2002] = 1969, [2003] = 2003, - [2004] = 2004, - [2005] = 1963, - [2006] = 1987, - [2007] = 2007, - [2008] = 2008, - [2009] = 1985, - [2010] = 2010, - [2011] = 1988, - [2012] = 1989, + [2004] = 1977, + [2005] = 1975, + [2006] = 1988, + [2007] = 1961, + [2008] = 1996, + [2009] = 1987, + [2010] = 1946, + [2011] = 2011, + [2012] = 2012, [2013] = 2013, - [2014] = 1957, + [2014] = 2014, [2015] = 2015, - [2016] = 1966, - [2017] = 1951, - [2018] = 1966, - [2019] = 1985, + [2016] = 2016, + [2017] = 2017, + [2018] = 2018, + [2019] = 2016, [2020] = 2020, - [2021] = 1988, - [2022] = 2022, - [2023] = 1954, - [2024] = 1951, - [2025] = 1964, - [2026] = 1988, - [2027] = 1981, - [2028] = 2004, + [2021] = 2016, + [2022] = 2013, + [2023] = 2014, + [2024] = 2014, + [2025] = 2020, + [2026] = 2026, + [2027] = 2013, + [2028] = 2028, [2029] = 2029, - [2030] = 1957, - [2031] = 1973, + [2030] = 2030, + [2031] = 2029, [2032] = 2032, - [2033] = 1987, - [2034] = 2032, - [2035] = 1987, - [2036] = 1972, - [2037] = 1985, - [2038] = 1963, - [2039] = 2015, - [2040] = 1961, + [2033] = 1897, + [2034] = 303, + [2035] = 302, + [2036] = 2036, + [2037] = 2017, + [2038] = 2038, + [2039] = 2039, + [2040] = 2040, [2041] = 2041, - [2042] = 1987, - [2043] = 2007, - [2044] = 1963, - [2045] = 1967, - [2046] = 1981, + [2042] = 2042, + [2043] = 2043, + [2044] = 2043, + [2045] = 2045, + [2046] = 2046, [2047] = 2047, [2048] = 2048, [2049] = 2049, - [2050] = 1948, - [2051] = 1971, - [2052] = 2022, - [2053] = 2020, + [2050] = 2050, + [2051] = 2051, + [2052] = 2052, + [2053] = 2053, [2054] = 2054, - [2055] = 1988, + [2055] = 2038, [2056] = 2056, - [2057] = 1967, - [2058] = 1967, - [2059] = 2056, - [2060] = 1967, - [2061] = 1981, - [2062] = 1972, - [2063] = 1947, - [2064] = 1963, - [2065] = 1971, - [2066] = 1954, - [2067] = 1973, - [2068] = 1966, - [2069] = 1992, - [2070] = 1947, - [2071] = 2008, - [2072] = 1981, - [2073] = 2010, - [2074] = 2047, - [2075] = 1947, - [2076] = 1953, - [2077] = 1952, + [2057] = 2057, + [2058] = 2058, + [2059] = 2059, + [2060] = 2060, + [2061] = 2061, + [2062] = 2062, + [2063] = 2063, + [2064] = 2046, + [2065] = 2065, + [2066] = 2045, + [2067] = 2067, + [2068] = 2068, + [2069] = 2069, + [2070] = 2070, + [2071] = 2046, + [2072] = 2061, + [2073] = 2056, + [2074] = 2074, + [2075] = 2041, + [2076] = 2076, + [2077] = 2076, [2078] = 2078, - [2079] = 2079, - [2080] = 2080, - [2081] = 2081, + [2079] = 2062, + [2080] = 2045, + [2081] = 2068, [2082] = 2082, - [2083] = 2083, + [2083] = 2042, [2084] = 2084, [2085] = 2085, - [2086] = 2086, - [2087] = 2079, - [2088] = 2086, + [2086] = 2065, + [2087] = 2059, + [2088] = 2088, [2089] = 2089, - [2090] = 2078, - [2091] = 2091, - [2092] = 2085, - [2093] = 2093, - [2094] = 2094, - [2095] = 2095, - [2096] = 2096, - [2097] = 2097, + [2090] = 2082, + [2091] = 2046, + [2092] = 2069, + [2093] = 2089, + [2094] = 2045, + [2095] = 2046, + [2096] = 2063, + [2097] = 2045, [2098] = 2098, [2099] = 2099, [2100] = 2100, [2101] = 2101, [2102] = 2102, - [2103] = 2091, + [2103] = 2103, [2104] = 2104, [2105] = 2098, - [2106] = 2106, + [2106] = 2098, [2107] = 2107, [2108] = 2108, [2109] = 2109, - [2110] = 2079, + [2110] = 2110, [2111] = 2111, [2112] = 2112, - [2113] = 2106, - [2114] = 2091, - [2115] = 2096, - [2116] = 2116, + [2113] = 2113, + [2114] = 2114, + [2115] = 2115, + [2116] = 2115, [2117] = 2117, [2118] = 2118, [2119] = 2119, - [2120] = 319, + [2120] = 2120, [2121] = 2121, [2122] = 2122, - [2123] = 2112, + [2123] = 2123, [2124] = 2124, [2125] = 2125, - [2126] = 2109, - [2127] = 2079, - [2128] = 2080, - [2129] = 2129, + [2126] = 2107, + [2127] = 2103, + [2128] = 2123, + [2129] = 2108, [2130] = 2130, - [2131] = 2106, - [2132] = 2091, + [2131] = 2122, + [2132] = 2132, [2133] = 2133, - [2134] = 2134, - [2135] = 2096, - [2136] = 2136, - [2137] = 2093, - [2138] = 2098, - [2139] = 2093, - [2140] = 279, - [2141] = 1894, - [2142] = 2078, - [2143] = 2143, - [2144] = 2091, - [2145] = 2106, - [2146] = 1925, - [2147] = 1922, - [2148] = 2094, - [2149] = 2100, - [2150] = 2150, - [2151] = 2151, - [2152] = 2096, - [2153] = 2079, - [2154] = 2154, - [2155] = 2109, - [2156] = 2078, - [2157] = 2098, - [2158] = 2158, - [2159] = 2159, - [2160] = 2093, - [2161] = 324, - [2162] = 2094, - [2163] = 2133, - [2164] = 2117, - [2165] = 2094, - [2166] = 2079, - [2167] = 2109, - [2168] = 2109, - [2169] = 2078, - [2170] = 2170, - [2171] = 2171, + [2134] = 2111, + [2135] = 2135, + [2136] = 2112, + [2137] = 2137, + [2138] = 2138, + [2139] = 2135, + [2140] = 2140, + [2141] = 2133, + [2142] = 2142, + [2143] = 2104, + [2144] = 2140, + [2145] = 2132, + [2146] = 2133, + [2147] = 2147, + [2148] = 2148, + [2149] = 2149, + [2150] = 2102, + [2151] = 2101, + [2152] = 2110, + [2153] = 2147, + [2154] = 2120, + [2155] = 2140, + [2156] = 2122, + [2157] = 2120, + [2158] = 2142, + [2159] = 2123, + [2160] = 2147, + [2161] = 2161, + [2162] = 2148, + [2163] = 2124, + [2164] = 2125, + [2165] = 2114, + [2166] = 2109, + [2167] = 2132, + [2168] = 2118, + [2169] = 2119, + [2170] = 2125, + [2171] = 2135, [2172] = 2172, - [2173] = 281, - [2174] = 2093, - [2175] = 2094, - [2176] = 2091, - [2177] = 2106, - [2178] = 2096, - [2179] = 2098, + [2173] = 2124, + [2174] = 2102, + [2175] = 2175, + [2176] = 2133, + [2177] = 2112, + [2178] = 2104, + [2179] = 2140, [2180] = 2180, - [2181] = 896, - [2182] = 2182, - [2183] = 2183, - [2184] = 2184, - [2185] = 2185, - [2186] = 2186, - [2187] = 2187, - [2188] = 2188, - [2189] = 2189, + [2181] = 2181, + [2182] = 2101, + [2183] = 2135, + [2184] = 2110, + [2185] = 2123, + [2186] = 2142, + [2187] = 2122, + [2188] = 2120, + [2189] = 2122, [2190] = 2190, - [2191] = 2191, - [2192] = 2192, - [2193] = 2193, - [2194] = 2194, - [2195] = 2195, - [2196] = 2196, - [2197] = 2194, - [2198] = 2198, - [2199] = 2199, + [2191] = 2123, + [2192] = 2125, + [2193] = 2120, + [2194] = 2110, + [2195] = 2124, + [2196] = 2101, + [2197] = 2197, + [2198] = 2140, + [2199] = 2124, [2200] = 2200, - [2201] = 2201, - [2202] = 2202, + [2201] = 2104, + [2202] = 2125, [2203] = 2203, - [2204] = 2204, - [2205] = 2205, + [2204] = 2132, + [2205] = 2148, [2206] = 2206, - [2207] = 2207, + [2207] = 2135, [2208] = 2208, - [2209] = 2209, - [2210] = 2210, + [2209] = 2132, + [2210] = 2110, [2211] = 2211, - [2212] = 2212, - [2213] = 2213, + [2212] = 2113, + [2213] = 2114, [2214] = 2214, - [2215] = 2215, - [2216] = 2214, - [2217] = 2217, - [2218] = 2185, - [2219] = 2219, - [2220] = 2220, - [2221] = 2186, + [2215] = 2101, + [2216] = 2133, + [2217] = 2109, + [2218] = 2218, + [2219] = 2104, + [2220] = 2121, + [2221] = 2117, [2222] = 2222, [2223] = 2223, [2224] = 2224, [2225] = 2225, [2226] = 2226, - [2227] = 2187, - [2228] = 2198, + [2227] = 2227, + [2228] = 2223, [2229] = 2229, [2230] = 2230, - [2231] = 2231, - [2232] = 2097, - [2233] = 2214, + [2231] = 2226, + [2232] = 2232, + [2233] = 2233, [2234] = 2234, - [2235] = 2212, + [2235] = 2235, [2236] = 2236, - [2237] = 2189, - [2238] = 2192, + [2237] = 2237, + [2238] = 2238, [2239] = 2239, [2240] = 2240, [2241] = 2229, - [2242] = 2204, - [2243] = 2205, - [2244] = 2185, - [2245] = 2203, - [2246] = 2201, - [2247] = 2225, - [2248] = 2198, - [2249] = 2209, - [2250] = 2239, - [2251] = 2229, - [2252] = 2180, - [2253] = 2121, - [2254] = 2254, - [2255] = 2205, - [2256] = 2191, - [2257] = 2257, - [2258] = 2201, + [2242] = 2242, + [2243] = 2243, + [2244] = 2244, + [2245] = 2245, + [2246] = 2246, + [2247] = 2247, + [2248] = 2244, + [2249] = 2249, + [2250] = 2250, + [2251] = 2251, + [2252] = 2240, + [2253] = 2253, + [2254] = 2242, + [2255] = 2255, + [2256] = 2256, + [2257] = 2237, + [2258] = 2258, [2259] = 2259, - [2260] = 2191, - [2261] = 2183, + [2260] = 2230, + [2261] = 2246, [2262] = 2262, - [2263] = 2226, - [2264] = 2239, - [2265] = 2225, - [2266] = 2183, - [2267] = 2257, - [2268] = 2268, + [2263] = 2263, + [2264] = 2264, + [2265] = 2265, + [2266] = 2236, + [2267] = 2225, + [2268] = 2223, [2269] = 2269, [2270] = 2270, - [2271] = 2190, - [2272] = 2272, - [2273] = 2185, - [2274] = 2274, - [2275] = 2188, - [2276] = 2186, - [2277] = 2277, - [2278] = 2198, + [2271] = 2233, + [2272] = 2238, + [2273] = 2269, + [2274] = 2264, + [2275] = 2239, + [2276] = 2238, + [2277] = 2269, + [2278] = 2263, [2279] = 2279, - [2280] = 2226, - [2281] = 2281, - [2282] = 2282, - [2283] = 2283, - [2284] = 2284, - [2285] = 2269, - [2286] = 2257, - [2287] = 2287, - [2288] = 2192, - [2289] = 2198, - [2290] = 2290, + [2280] = 2270, + [2281] = 2239, + [2282] = 2240, + [2283] = 2235, + [2284] = 2229, + [2285] = 2243, + [2286] = 2244, + [2287] = 2245, + [2288] = 2247, + [2289] = 2233, + [2290] = 2249, [2291] = 2291, - [2292] = 2292, - [2293] = 2269, - [2294] = 2189, - [2295] = 2277, - [2296] = 2296, - [2297] = 2272, - [2298] = 2268, - [2299] = 2274, - [2300] = 2188, - [2301] = 2301, - [2302] = 2190, - [2303] = 2204, - [2304] = 2254, - [2305] = 2196, - [2306] = 2193, - [2307] = 2214, - [2308] = 2200, - [2309] = 2217, - [2310] = 2224, + [2292] = 2250, + [2293] = 2270, + [2294] = 2294, + [2295] = 2242, + [2296] = 2250, + [2297] = 2256, + [2298] = 2237, + [2299] = 2223, + [2300] = 2245, + [2301] = 2225, + [2302] = 2302, + [2303] = 2263, + [2304] = 2230, + [2305] = 2230, + [2306] = 2306, + [2307] = 2237, + [2308] = 2263, + [2309] = 2256, + [2310] = 2242, [2311] = 2311, - [2312] = 2312, - [2313] = 2262, + [2312] = 2249, + [2313] = 2225, [2314] = 2314, - [2315] = 2282, + [2315] = 2315, [2316] = 2316, - [2317] = 2193, - [2318] = 2318, - [2319] = 2212, - [2320] = 2196, - [2321] = 2196, - [2322] = 957, - [2323] = 2212, - [2324] = 2324, - [2325] = 2301, - [2326] = 2326, - [2327] = 2327, + [2317] = 2223, + [2318] = 2250, + [2319] = 2256, + [2320] = 2249, + [2321] = 2233, + [2322] = 2247, + [2323] = 2238, + [2324] = 2245, + [2325] = 2314, + [2326] = 2244, + [2327] = 2243, [2328] = 2328, - [2329] = 2284, - [2330] = 2202, - [2331] = 2222, - [2332] = 2290, - [2333] = 2210, - [2334] = 920, - [2335] = 919, - [2336] = 2189, - [2337] = 2193, - [2338] = 850, - [2339] = 2195, - [2340] = 914, - [2341] = 2203, - [2342] = 2186, - [2343] = 2192, - [2344] = 2324, - [2345] = 2345, - [2346] = 913, - [2347] = 912, - [2348] = 911, - [2349] = 910, - [2350] = 909, - [2351] = 2311, - [2352] = 2287, - [2353] = 908, - [2354] = 2224, - [2355] = 907, - [2356] = 2200, - [2357] = 906, - [2358] = 905, - [2359] = 904, - [2360] = 903, - [2361] = 902, - [2362] = 2202, - [2363] = 2195, - [2364] = 901, - [2365] = 900, - [2366] = 899, - [2367] = 898, - [2368] = 897, + [2329] = 2229, + [2330] = 2269, + [2331] = 2240, + [2332] = 2270, + [2333] = 2239, + [2334] = 2316, + [2335] = 2239, + [2336] = 2240, + [2337] = 2243, + [2338] = 2229, + [2339] = 2243, + [2340] = 2244, + [2341] = 2270, + [2342] = 2269, + [2343] = 2245, + [2344] = 2247, + [2345] = 2247, + [2346] = 2346, + [2347] = 2249, + [2348] = 2250, + [2349] = 2238, + [2350] = 2233, + [2351] = 2242, + [2352] = 2256, + [2353] = 2237, + [2354] = 2230, + [2355] = 2263, + [2356] = 2225, + [2357] = 2357, + [2358] = 2358, + [2359] = 2359, + [2360] = 2360, + [2361] = 2361, + [2362] = 2362, + [2363] = 2358, + [2364] = 2364, + [2365] = 2365, + [2366] = 2366, + [2367] = 2367, + [2368] = 2368, [2369] = 2369, - [2370] = 2223, - [2371] = 2369, - [2372] = 891, - [2373] = 2369, - [2374] = 2224, - [2375] = 2209, - [2376] = 890, - [2377] = 2268, - [2378] = 889, - [2379] = 2182, - [2380] = 2268, - [2381] = 888, - [2382] = 2281, - [2383] = 2225, - [2384] = 2291, - [2385] = 2239, - [2386] = 2229, - [2387] = 887, - [2388] = 2291, - [2389] = 886, - [2390] = 2187, - [2391] = 2210, - [2392] = 2231, - [2393] = 2200, - [2394] = 2290, - [2395] = 2205, - [2396] = 2254, - [2397] = 885, - [2398] = 2270, - [2399] = 884, - [2400] = 2291, - [2401] = 883, - [2402] = 2301, - [2403] = 882, - [2404] = 881, - [2405] = 2292, - [2406] = 2201, - [2407] = 2327, - [2408] = 2191, - [2409] = 2284, - [2410] = 880, - [2411] = 2282, - [2412] = 2301, - [2413] = 879, - [2414] = 851, - [2415] = 2415, - [2416] = 2270, - [2417] = 852, - [2418] = 2231, - [2419] = 2200, - [2420] = 2224, - [2421] = 2421, - [2422] = 2188, - [2423] = 2183, - [2424] = 2190, - [2425] = 2226, - [2426] = 2272, - [2427] = 2190, - [2428] = 2194, + [2370] = 2370, + [2371] = 2371, + [2372] = 2372, + [2373] = 2373, + [2374] = 1113, + [2375] = 2375, + [2376] = 2376, + [2377] = 2372, + [2378] = 2378, + [2379] = 2379, + [2380] = 1199, + [2381] = 2369, + [2382] = 2376, + [2383] = 2383, + [2384] = 2368, + [2385] = 2385, + [2386] = 2386, + [2387] = 2387, + [2388] = 2388, + [2389] = 2358, + [2390] = 2390, + [2391] = 2391, + [2392] = 2370, + [2393] = 2393, + [2394] = 2357, + [2395] = 2395, + [2396] = 2396, + [2397] = 2397, + [2398] = 2398, + [2399] = 2399, + [2400] = 1275, + [2401] = 2401, + [2402] = 2357, + [2403] = 2403, + [2404] = 2404, + [2405] = 2357, + [2406] = 2406, + [2407] = 2407, + [2408] = 2372, + [2409] = 2358, + [2410] = 2410, + [2411] = 1238, + [2412] = 2412, + [2413] = 2413, + [2414] = 2372, + [2415] = 2368, + [2416] = 2369, + [2417] = 1193, + [2418] = 2369, + [2419] = 309, + [2420] = 2372, + [2421] = 2368, + [2422] = 2422, + [2423] = 2423, + [2424] = 2424, + [2425] = 2367, + [2426] = 2426, + [2427] = 2427, + [2428] = 2428, [2429] = 2429, - [2430] = 2189, - [2431] = 853, - [2432] = 854, - [2433] = 855, - [2434] = 2231, - [2435] = 2210, - [2436] = 856, - [2437] = 2290, - [2438] = 2268, - [2439] = 857, - [2440] = 2262, - [2441] = 2257, - [2442] = 2209, - [2443] = 2269, + [2430] = 2430, + [2431] = 2431, + [2432] = 2432, + [2433] = 1144, + [2434] = 2434, + [2435] = 2435, + [2436] = 2357, + [2437] = 2437, + [2438] = 2430, + [2439] = 2439, + [2440] = 2440, + [2441] = 2431, + [2442] = 298, + [2443] = 2443, [2444] = 2444, - [2445] = 858, - [2446] = 2292, + [2445] = 2445, + [2446] = 2446, [2447] = 2447, - [2448] = 2188, - [2449] = 859, - [2450] = 2215, - [2451] = 860, - [2452] = 2272, - [2453] = 861, - [2454] = 2203, - [2455] = 2274, - [2456] = 2204, - [2457] = 2274, - [2458] = 2458, - [2459] = 2180, - [2460] = 862, - [2461] = 863, + [2448] = 323, + [2449] = 2430, + [2450] = 2437, + [2451] = 2451, + [2452] = 2369, + [2453] = 2453, + [2454] = 2454, + [2455] = 2437, + [2456] = 2437, + [2457] = 2430, + [2458] = 2440, + [2459] = 2431, + [2460] = 2430, + [2461] = 2368, [2462] = 2462, - [2463] = 864, - [2464] = 865, - [2465] = 2274, - [2466] = 2429, - [2467] = 2272, - [2468] = 2182, - [2469] = 2207, - [2470] = 866, - [2471] = 2270, - [2472] = 2185, - [2473] = 867, - [2474] = 2269, - [2475] = 2262, - [2476] = 868, - [2477] = 869, - [2478] = 870, - [2479] = 871, - [2480] = 2282, - [2481] = 2284, - [2482] = 2257, - [2483] = 2254, - [2484] = 2187, - [2485] = 872, - [2486] = 2292, - [2487] = 873, - [2488] = 2194, - [2489] = 2231, - [2490] = 2259, - [2491] = 2210, - [2492] = 2209, - [2493] = 2262, - [2494] = 2220, - [2495] = 2184, + [2463] = 295, + [2464] = 2464, + [2465] = 2369, + [2466] = 2466, + [2467] = 2467, + [2468] = 2190, + [2469] = 2469, + [2470] = 2437, + [2471] = 2430, + [2472] = 2440, + [2473] = 2431, + [2474] = 2440, + [2475] = 2431, + [2476] = 2358, + [2477] = 2181, + [2478] = 2478, + [2479] = 2479, + [2480] = 2480, + [2481] = 2467, + [2482] = 2200, + [2483] = 2197, + [2484] = 2440, + [2485] = 2485, + [2486] = 2430, + [2487] = 2412, + [2488] = 2431, + [2489] = 2437, + [2490] = 2431, + [2491] = 2440, + [2492] = 2492, + [2493] = 2493, + [2494] = 2424, + [2495] = 2495, [2496] = 2496, - [2497] = 2203, - [2498] = 874, - [2499] = 875, - [2500] = 876, - [2501] = 877, - [2502] = 2180, - [2503] = 2204, - [2504] = 2415, - [2505] = 2505, - [2506] = 2301, - [2507] = 2270, - [2508] = 2226, - [2509] = 2183, - [2510] = 2369, - [2511] = 2444, - [2512] = 878, - [2513] = 893, - [2514] = 894, - [2515] = 2290, - [2516] = 2291, - [2517] = 2505, - [2518] = 895, - [2519] = 2254, - [2520] = 2212, - [2521] = 2191, - [2522] = 2214, - [2523] = 2369, - [2524] = 2195, - [2525] = 2187, - [2526] = 2182, - [2527] = 2194, - [2528] = 2201, - [2529] = 915, - [2530] = 2196, - [2531] = 2284, - [2532] = 2198, - [2533] = 2292, - [2534] = 916, + [2497] = 983, + [2498] = 2498, + [2499] = 982, + [2500] = 980, + [2501] = 2501, + [2502] = 979, + [2503] = 2503, + [2504] = 2504, + [2505] = 2498, + [2506] = 2504, + [2507] = 2498, + [2508] = 978, + [2509] = 2504, + [2510] = 977, + [2511] = 2498, + [2512] = 976, + [2513] = 2407, + [2514] = 2514, + [2515] = 975, + [2516] = 2516, + [2517] = 2517, + [2518] = 2518, + [2519] = 2504, + [2520] = 2520, + [2521] = 2379, + [2522] = 2498, + [2523] = 2496, + [2524] = 2524, + [2525] = 2525, + [2526] = 2526, + [2527] = 2527, + [2528] = 2528, + [2529] = 2524, + [2530] = 2496, + [2531] = 2531, + [2532] = 2532, + [2533] = 2533, + [2534] = 2534, [2535] = 2535, - [2536] = 918, - [2537] = 2447, - [2538] = 2538, - [2539] = 921, - [2540] = 2192, - [2541] = 2282, - [2542] = 2195, - [2543] = 2543, - [2544] = 2421, - [2545] = 2545, - [2546] = 2205, - [2547] = 2229, - [2548] = 2239, - [2549] = 2549, - [2550] = 2225, - [2551] = 2202, - [2552] = 2182, - [2553] = 2193, - [2554] = 2202, - [2555] = 2180, - [2556] = 2185, - [2557] = 2186, + [2536] = 2536, + [2537] = 2537, + [2538] = 2520, + [2539] = 2539, + [2540] = 2526, + [2541] = 2541, + [2542] = 2496, + [2543] = 2526, + [2544] = 2536, + [2545] = 2520, + [2546] = 2546, + [2547] = 2547, + [2548] = 2548, + [2549] = 974, + [2550] = 2550, + [2551] = 2551, + [2552] = 2552, + [2553] = 972, + [2554] = 2554, + [2555] = 2555, + [2556] = 2556, + [2557] = 2524, [2558] = 2558, - [2559] = 1405, + [2559] = 971, [2560] = 2560, - [2561] = 2561, - [2562] = 2562, - [2563] = 2561, + [2561] = 2541, + [2562] = 970, + [2563] = 969, [2564] = 2564, - [2565] = 2565, - [2566] = 2566, - [2567] = 2560, + [2565] = 968, + [2566] = 967, + [2567] = 966, [2568] = 2568, - [2569] = 2569, + [2569] = 2564, [2570] = 2570, - [2571] = 2570, + [2571] = 965, [2572] = 2572, [2573] = 2573, [2574] = 2574, - [2575] = 2575, - [2576] = 2566, + [2575] = 1402, + [2576] = 2576, [2577] = 2577, - [2578] = 2578, - [2579] = 2568, + [2578] = 932, + [2579] = 2579, [2580] = 2580, - [2581] = 2581, - [2582] = 2569, + [2581] = 984, + [2582] = 963, [2583] = 2583, - [2584] = 2584, - [2585] = 2564, - [2586] = 2586, - [2587] = 2573, - [2588] = 2574, + [2584] = 962, + [2585] = 961, + [2586] = 960, + [2587] = 985, + [2588] = 959, [2589] = 2589, [2590] = 2590, [2591] = 2591, - [2592] = 2578, - [2593] = 2583, + [2592] = 2592, + [2593] = 2593, [2594] = 2594, [2595] = 2595, - [2596] = 2565, + [2596] = 2596, [2597] = 2597, - [2598] = 2564, - [2599] = 2599, - [2600] = 2589, + [2598] = 2556, + [2599] = 2568, + [2600] = 958, [2601] = 2601, - [2602] = 2602, - [2603] = 2603, + [2602] = 2525, + [2603] = 957, [2604] = 2604, - [2605] = 2605, - [2606] = 2606, - [2607] = 2607, - [2608] = 2608, - [2609] = 2565, - [2610] = 2610, + [2605] = 956, + [2606] = 955, + [2607] = 954, + [2608] = 953, + [2609] = 952, + [2610] = 2527, [2611] = 2611, [2612] = 2612, [2613] = 2613, - [2614] = 2564, + [2614] = 2614, [2615] = 2615, [2616] = 2616, [2617] = 2617, @@ -5489,702 +5718,1198 @@ static const TSStateId ts_primary_state_ids[STATE_COUNT] = { [2619] = 2619, [2620] = 2620, [2621] = 2621, - [2622] = 2622, - [2623] = 2623, - [2624] = 2624, - [2625] = 2625, - [2626] = 2626, - [2627] = 2627, - [2628] = 2628, - [2629] = 2629, - [2630] = 2630, - [2631] = 2589, + [2622] = 2535, + [2623] = 2570, + [2624] = 2595, + [2625] = 2594, + [2626] = 2583, + [2627] = 942, + [2628] = 951, + [2629] = 950, + [2630] = 949, + [2631] = 948, [2632] = 2632, - [2633] = 2565, - [2634] = 2564, + [2633] = 2633, + [2634] = 2634, [2635] = 2635, - [2636] = 2594, - [2637] = 2637, - [2638] = 2638, + [2636] = 2619, + [2637] = 2536, + [2638] = 3, [2639] = 2639, - [2640] = 2640, + [2640] = 2520, [2641] = 2641, [2642] = 2642, - [2643] = 2643, - [2644] = 2644, - [2645] = 2645, - [2646] = 2646, - [2647] = 2617, - [2648] = 2648, - [2649] = 2649, - [2650] = 2650, - [2651] = 2651, - [2652] = 2652, - [2653] = 2653, - [2654] = 2654, - [2655] = 2589, - [2656] = 2656, - [2657] = 2656, - [2658] = 2606, - [2659] = 2659, - [2660] = 2586, - [2661] = 2575, - [2662] = 2570, - [2663] = 2604, - [2664] = 2664, - [2665] = 2665, - [2666] = 2565, - [2667] = 2589, - [2668] = 2564, - [2669] = 2562, - [2670] = 2569, - [2671] = 2671, - [2672] = 2580, - [2673] = 2581, - [2674] = 2584, - [2675] = 2654, - [2676] = 2590, - [2677] = 2591, - [2678] = 2595, - [2679] = 2597, - [2680] = 2599, - [2681] = 2611, - [2682] = 2601, - [2683] = 2616, - [2684] = 2684, - [2685] = 2602, - [2686] = 2686, - [2687] = 2687, - [2688] = 2688, + [2643] = 2546, + [2644] = 2547, + [2645] = 2548, + [2646] = 2617, + [2647] = 2550, + [2648] = 2618, + [2649] = 2551, + [2650] = 2552, + [2651] = 2554, + [2652] = 2555, + [2653] = 2558, + [2654] = 2560, + [2655] = 2541, + [2656] = 2564, + [2657] = 2657, + [2658] = 2573, + [2659] = 2574, + [2660] = 2576, + [2661] = 2577, + [2662] = 2589, + [2663] = 2590, + [2664] = 2591, + [2665] = 2592, + [2666] = 986, + [2667] = 2594, + [2668] = 2595, + [2669] = 2669, + [2670] = 2620, + [2671] = 2621, + [2672] = 2596, + [2673] = 2597, + [2674] = 2556, + [2675] = 2568, + [2676] = 2676, + [2677] = 2614, + [2678] = 2596, + [2679] = 2604, + [2680] = 2611, + [2681] = 2612, + [2682] = 2614, + [2683] = 2632, + [2684] = 2501, + [2685] = 2685, + [2686] = 2617, + [2687] = 2517, + [2688] = 987, [2689] = 2689, - [2690] = 2603, - [2691] = 2607, - [2692] = 2608, - [2693] = 2610, - [2694] = 2612, - [2695] = 2613, - [2696] = 2615, - [2697] = 2697, - [2698] = 2618, - [2699] = 2653, - [2700] = 2619, - [2701] = 2620, - [2702] = 2621, - [2703] = 2622, - [2704] = 2623, - [2705] = 2624, - [2706] = 2625, - [2707] = 2626, - [2708] = 2627, - [2709] = 2617, - [2710] = 2558, + [2690] = 2, + [2691] = 2618, + [2692] = 988, + [2693] = 2619, + [2694] = 2496, + [2695] = 947, + [2696] = 2526, + [2697] = 2620, + [2698] = 946, + [2699] = 2621, + [2700] = 945, + [2701] = 2701, + [2702] = 2702, + [2703] = 944, + [2704] = 2535, + [2705] = 2597, + [2706] = 2570, + [2707] = 2583, + [2708] = 2616, + [2709] = 2633, + [2710] = 2634, [2711] = 2711, - [2712] = 2628, - [2713] = 2632, - [2714] = 2635, - [2715] = 2637, - [2716] = 2638, - [2717] = 2639, - [2718] = 2642, - [2719] = 2643, - [2720] = 2629, - [2721] = 2644, - [2722] = 2645, - [2723] = 2723, - [2724] = 2648, - [2725] = 2649, - [2726] = 2652, - [2727] = 2654, - [2728] = 2728, - [2729] = 2630, - [2730] = 2656, - [2731] = 2606, - [2732] = 2652, - [2733] = 2649, - [2734] = 2605, - [2735] = 2570, + [2712] = 2612, + [2713] = 2536, + [2714] = 2528, + [2715] = 2639, + [2716] = 2520, + [2717] = 2717, + [2718] = 2546, + [2719] = 2547, + [2720] = 2548, + [2721] = 2550, + [2722] = 2551, + [2723] = 2552, + [2724] = 2554, + [2725] = 2555, + [2726] = 2558, + [2727] = 2560, + [2728] = 2541, + [2729] = 2564, + [2730] = 2573, + [2731] = 2574, + [2732] = 2576, + [2733] = 989, + [2734] = 2577, + [2735] = 2592, [2736] = 2736, - [2737] = 2648, - [2738] = 2738, - [2739] = 2739, - [2740] = 2740, - [2741] = 2580, - [2742] = 2581, - [2743] = 2584, - [2744] = 2586, - [2745] = 2590, - [2746] = 2591, - [2747] = 2595, - [2748] = 2597, - [2749] = 2599, - [2750] = 2601, - [2751] = 2602, - [2752] = 2603, - [2753] = 2607, - [2754] = 2608, - [2755] = 2610, - [2756] = 2612, - [2757] = 2613, - [2758] = 2615, - [2759] = 2618, - [2760] = 2619, - [2761] = 2620, - [2762] = 2621, - [2763] = 2622, - [2764] = 2623, - [2765] = 2624, - [2766] = 2625, - [2767] = 2626, - [2768] = 2627, - [2769] = 2628, - [2770] = 2632, + [2737] = 2589, + [2738] = 990, + [2739] = 2590, + [2740] = 940, + [2741] = 2741, + [2742] = 2742, + [2743] = 2591, + [2744] = 2592, + [2745] = 2591, + [2746] = 939, + [2747] = 2594, + [2748] = 938, + [2749] = 2595, + [2750] = 2546, + [2751] = 2596, + [2752] = 2597, + [2753] = 2753, + [2754] = 2754, + [2755] = 2755, + [2756] = 2556, + [2757] = 2568, + [2758] = 2531, + [2759] = 2604, + [2760] = 2611, + [2761] = 2612, + [2762] = 2614, + [2763] = 2573, + [2764] = 2764, + [2765] = 2765, + [2766] = 2617, + [2767] = 2503, + [2768] = 2618, + [2769] = 2619, + [2770] = 2633, [2771] = 2771, - [2772] = 2635, - [2773] = 2640, - [2774] = 2637, - [2775] = 2569, - [2776] = 2776, - [2777] = 2638, - [2778] = 2641, - [2779] = 2639, - [2780] = 2642, - [2781] = 2643, - [2782] = 2644, - [2783] = 2783, - [2784] = 2645, - [2785] = 2577, - [2786] = 2786, - [2787] = 2648, - [2788] = 2649, - [2789] = 2652, - [2790] = 2611, - [2791] = 2654, - [2792] = 2792, - [2793] = 2656, - [2794] = 2606, - [2795] = 2795, - [2796] = 2650, - [2797] = 2797, - [2798] = 2570, - [2799] = 2651, - [2800] = 2800, - [2801] = 2801, - [2802] = 2645, - [2803] = 2803, - [2804] = 2804, - [2805] = 2632, - [2806] = 2580, - [2807] = 2581, - [2808] = 2644, - [2809] = 2584, - [2810] = 2586, - [2811] = 2590, - [2812] = 2591, - [2813] = 2595, - [2814] = 2597, - [2815] = 2599, - [2816] = 2601, - [2817] = 2602, - [2818] = 2603, - [2819] = 2643, - [2820] = 2642, - [2821] = 2639, - [2822] = 2607, - [2823] = 2608, - [2824] = 2610, - [2825] = 2825, - [2826] = 2826, - [2827] = 2827, - [2828] = 2828, + [2772] = 2620, + [2773] = 2621, + [2774] = 2774, + [2775] = 2535, + [2776] = 2570, + [2777] = 2634, + [2778] = 2583, + [2779] = 2547, + [2780] = 2548, + [2781] = 2633, + [2782] = 2634, + [2783] = 2536, + [2784] = 2784, + [2785] = 2785, + [2786] = 2639, + [2787] = 2554, + [2788] = 2788, + [2789] = 2574, + [2790] = 2790, + [2791] = 2520, + [2792] = 2546, + [2793] = 2547, + [2794] = 2548, + [2795] = 2550, + [2796] = 2551, + [2797] = 2552, + [2798] = 2554, + [2799] = 2555, + [2800] = 2558, + [2801] = 2560, + [2802] = 2755, + [2803] = 2541, + [2804] = 2564, + [2805] = 2573, + [2806] = 2574, + [2807] = 2576, + [2808] = 2577, + [2809] = 937, + [2810] = 2810, + [2811] = 996, + [2812] = 2812, + [2813] = 2589, + [2814] = 2590, + [2815] = 2815, + [2816] = 2591, + [2817] = 2592, + [2818] = 2818, + [2819] = 2819, + [2820] = 2594, + [2821] = 2595, + [2822] = 991, + [2823] = 992, + [2824] = 2496, + [2825] = 2560, + [2826] = 2526, + [2827] = 2576, + [2828] = 2516, [2829] = 2829, - [2830] = 2612, - [2831] = 2831, - [2832] = 2638, - [2833] = 2833, - [2834] = 2613, - [2835] = 2615, - [2836] = 2618, - [2837] = 2619, - [2838] = 2620, - [2839] = 2839, - [2840] = 2840, - [2841] = 2841, - [2842] = 2842, - [2843] = 2843, - [2844] = 2844, - [2845] = 2621, - [2846] = 2622, - [2847] = 2687, - [2848] = 2688, - [2849] = 2623, - [2850] = 2624, - [2851] = 2625, - [2852] = 2626, - [2853] = 2689, - [2854] = 2854, - [2855] = 2855, - [2856] = 2611, - [2857] = 2857, - [2858] = 2637, - [2859] = 2859, - [2860] = 2860, - [2861] = 2627, - [2862] = 2628, - [2863] = 2863, - [2864] = 2635, - [2865] = 2637, + [2830] = 2596, + [2831] = 2597, + [2832] = 2611, + [2833] = 2556, + [2834] = 2568, + [2835] = 2534, + [2836] = 993, + [2837] = 994, + [2838] = 2838, + [2839] = 2558, + [2840] = 2604, + [2841] = 2611, + [2842] = 2612, + [2843] = 2614, + [2844] = 2815, + [2845] = 2617, + [2846] = 2846, + [2847] = 2642, + [2848] = 2577, + [2849] = 2849, + [2850] = 2850, + [2851] = 2618, + [2852] = 2619, + [2853] = 2514, + [2854] = 2620, + [2855] = 2621, + [2856] = 2702, + [2857] = 1016, + [2858] = 2535, + [2859] = 2533, + [2860] = 2570, + [2861] = 1015, + [2862] = 2590, + [2863] = 2536, + [2864] = 2589, + [2865] = 1014, [2866] = 2866, - [2867] = 2635, - [2868] = 2841, - [2869] = 2638, - [2870] = 2632, - [2871] = 2628, - [2872] = 2627, - [2873] = 2860, - [2874] = 2569, - [2875] = 2829, - [2876] = 2827, - [2877] = 2826, - [2878] = 2697, - [2879] = 2857, - [2880] = 2639, - [2881] = 2642, - [2882] = 2643, - [2883] = 2644, - [2884] = 2645, - [2885] = 2855, - [2886] = 2854, - [2887] = 2786, - [2888] = 2888, - [2889] = 2626, - [2890] = 2686, - [2891] = 2776, - [2892] = 2771, - [2893] = 2739, - [2894] = 2648, - [2895] = 2736, - [2896] = 2803, - [2897] = 2649, - [2898] = 2652, - [2899] = 2624, - [2900] = 2623, - [2901] = 2711, - [2902] = 2902, - [2903] = 2622, - [2904] = 2654, - [2905] = 2905, - [2906] = 2906, - [2907] = 2569, + [2867] = 2867, + [2868] = 2583, + [2869] = 2550, + [2870] = 2635, + [2871] = 2871, + [2872] = 1013, + [2873] = 1011, + [2874] = 1010, + [2875] = 1009, + [2876] = 2876, + [2877] = 2633, + [2878] = 2634, + [2879] = 2879, + [2880] = 2604, + [2881] = 2881, + [2882] = 2882, + [2883] = 2536, + [2884] = 2551, + [2885] = 2552, + [2886] = 2639, + [2887] = 1008, + [2888] = 1007, + [2889] = 2520, + [2890] = 1006, + [2891] = 1005, + [2892] = 1004, + [2893] = 1003, + [2894] = 1002, + [2895] = 1001, + [2896] = 1000, + [2897] = 2897, + [2898] = 2898, + [2899] = 2641, + [2900] = 2900, + [2901] = 2901, + [2902] = 2496, + [2903] = 999, + [2904] = 2904, + [2905] = 2555, + [2906] = 2532, + [2907] = 995, [2908] = 2908, - [2909] = 2665, - [2910] = 2910, - [2911] = 2911, - [2912] = 2659, - [2913] = 2656, - [2914] = 2606, - [2915] = 2621, - [2916] = 2844, - [2917] = 2625, - [2918] = 2839, - [2919] = 2620, - [2920] = 2619, - [2921] = 2570, - [2922] = 2611, - [2923] = 2618, - [2924] = 2615, - [2925] = 2613, - [2926] = 2833, + [2909] = 2909, + [2910] = 2504, + [2911] = 2639, + [2912] = 998, + [2913] = 2526, + [2914] = 2914, + [2915] = 997, + [2916] = 2593, + [2917] = 2917, + [2918] = 2918, + [2919] = 2919, + [2920] = 2920, + [2921] = 2921, + [2922] = 2922, + [2923] = 2923, + [2924] = 2924, + [2925] = 2925, + [2926] = 2926, [2927] = 2927, - [2928] = 2728, + [2928] = 2928, [2929] = 2929, - [2930] = 2612, - [2931] = 1083, - [2932] = 2129, + [2930] = 2930, + [2931] = 2931, + [2932] = 2932, [2933] = 2933, - [2934] = 2934, + [2934] = 2932, [2935] = 2935, [2936] = 2936, - [2937] = 2104, - [2938] = 2934, - [2939] = 2172, + [2937] = 2937, + [2938] = 2938, + [2939] = 2939, [2940] = 2940, - [2941] = 2783, - [2942] = 2738, - [2943] = 2607, - [2944] = 2580, - [2945] = 2581, - [2946] = 2584, + [2941] = 2941, + [2942] = 2942, + [2943] = 2943, + [2944] = 2939, + [2945] = 2945, + [2946] = 2946, [2947] = 2947, - [2948] = 2586, - [2949] = 2590, + [2948] = 2948, + [2949] = 2949, [2950] = 2950, - [2951] = 2828, - [2952] = 2591, - [2953] = 2595, - [2954] = 2954, - [2955] = 2597, - [2956] = 2599, - [2957] = 2957, - [2958] = 2601, - [2959] = 2825, - [2960] = 2602, - [2961] = 2610, + [2951] = 2941, + [2952] = 2942, + [2953] = 2953, + [2954] = 2943, + [2955] = 2945, + [2956] = 2956, + [2957] = 2946, + [2958] = 2940, + [2959] = 2959, + [2960] = 2948, + [2961] = 2961, [2962] = 2962, - [2963] = 2608, - [2964] = 2740, - [2965] = 2603, - [2966] = 2966, - [2967] = 2840, + [2963] = 2963, + [2964] = 2964, + [2965] = 2965, + [2966] = 2383, + [2967] = 2949, [2968] = 2968, - [2969] = 2969, - [2970] = 2970, - [2971] = 2971, + [2969] = 2950, + [2970] = 2961, + [2971] = 2965, [2972] = 2972, - [2973] = 2973, - [2974] = 2974, + [2973] = 2972, + [2974] = 2922, [2975] = 2975, [2976] = 2976, [2977] = 2977, [2978] = 2978, - [2979] = 2979, - [2980] = 2969, + [2979] = 2978, + [2980] = 2980, [2981] = 2981, - [2982] = 2982, - [2983] = 2983, + [2982] = 2937, + [2983] = 2956, [2984] = 2984, [2985] = 2985, - [2986] = 2986, + [2986] = 2365, [2987] = 2987, - [2988] = 2988, + [2988] = 2963, [2989] = 2989, [2990] = 2990, [2991] = 2991, - [2992] = 2992, + [2992] = 2962, [2993] = 2993, [2994] = 2994, - [2995] = 2983, - [2996] = 2970, - [2997] = 2997, + [2995] = 2993, + [2996] = 2996, + [2997] = 2993, [2998] = 2998, [2999] = 2999, [3000] = 3000, - [3001] = 3001, + [3001] = 2993, [3002] = 3002, [3003] = 3003, - [3004] = 3004, - [3005] = 3005, - [3006] = 3006, - [3007] = 3007, + [3004] = 2999, + [3005] = 3000, + [3006] = 2941, + [3007] = 2975, [3008] = 3008, - [3009] = 3009, + [3009] = 2993, [3010] = 3010, - [3011] = 3011, - [3012] = 3012, - [3013] = 3013, + [3011] = 2999, + [3012] = 3000, + [3013] = 2993, [3014] = 3014, [3015] = 3015, - [3016] = 3016, + [3016] = 2920, [3017] = 3017, [3018] = 3018, - [3019] = 3019, + [3019] = 2999, [3020] = 3020, - [3021] = 2969, + [3021] = 3021, [3022] = 3022, - [3023] = 3023, - [3024] = 3024, - [3025] = 3025, + [3023] = 2939, + [3024] = 2989, + [3025] = 2978, [3026] = 3026, - [3027] = 3027, + [3027] = 2947, [3028] = 3028, - [3029] = 3029, - [3030] = 3030, - [3031] = 3031, - [3032] = 3032, + [3029] = 2956, + [3030] = 2937, + [3031] = 2996, + [3032] = 3000, [3033] = 3033, [3034] = 3034, - [3035] = 3013, + [3035] = 2956, [3036] = 3036, - [3037] = 3012, - [3038] = 3038, - [3039] = 3039, - [3040] = 3010, + [3037] = 3037, + [3038] = 2993, + [3039] = 2964, + [3040] = 3040, [3041] = 3041, - [3042] = 3009, + [3042] = 3042, [3043] = 3043, - [3044] = 3044, + [3044] = 2935, [3045] = 3045, [3046] = 3046, - [3047] = 3007, - [3048] = 3048, - [3049] = 3000, - [3050] = 3050, + [3047] = 3047, + [3048] = 2923, + [3049] = 2996, + [3050] = 2962, [3051] = 3051, - [3052] = 3033, - [3053] = 3032, - [3054] = 3030, - [3055] = 3050, - [3056] = 3024, - [3057] = 2969, - [3058] = 3016, - [3059] = 3048, - [3060] = 3004, + [3052] = 3052, + [3053] = 2994, + [3054] = 2931, + [3055] = 2938, + [3056] = 3056, + [3057] = 3057, + [3058] = 3058, + [3059] = 3059, + [3060] = 3060, [3061] = 3061, - [3062] = 3003, - [3063] = 3063, - [3064] = 2986, - [3065] = 3001, - [3066] = 2985, - [3067] = 2984, - [3068] = 2973, - [3069] = 2974, - [3070] = 2975, - [3071] = 2982, - [3072] = 2973, - [3073] = 3046, - [3074] = 3045, + [3062] = 2996, + [3063] = 2942, + [3064] = 2956, + [3065] = 3052, + [3066] = 3066, + [3067] = 3067, + [3068] = 3068, + [3069] = 3069, + [3070] = 3070, + [3071] = 3071, + [3072] = 2963, + [3073] = 3073, + [3074] = 3074, [3075] = 3075, [3076] = 3076, - [3077] = 3044, - [3078] = 3043, - [3079] = 3039, - [3080] = 2974, - [3081] = 3081, - [3082] = 2981, - [3083] = 3083, - [3084] = 2975, - [3085] = 3085, - [3086] = 2978, - [3087] = 2977, - [3088] = 3038, - [3089] = 3031, - [3090] = 3090, + [3077] = 3077, + [3078] = 2924, + [3079] = 3074, + [3080] = 3026, + [3081] = 3015, + [3082] = 3082, + [3083] = 3059, + [3084] = 3047, + [3085] = 2987, + [3086] = 3086, + [3087] = 2994, + [3088] = 3076, + [3089] = 3073, + [3090] = 3015, [3091] = 3091, - [3092] = 2975, - [3093] = 2981, - [3094] = 2974, - [3095] = 2973, - [3096] = 2981, - [3097] = 2982, + [3092] = 3092, + [3093] = 2935, + [3094] = 3067, + [3095] = 2968, + [3096] = 3096, + [3097] = 3097, [3098] = 3098, - [3099] = 2984, - [3100] = 3100, - [3101] = 2985, - [3102] = 2987, - [3103] = 2986, - [3104] = 3008, - [3105] = 3105, + [3099] = 2961, + [3100] = 2930, + [3101] = 3101, + [3102] = 2956, + [3103] = 3026, + [3104] = 2926, + [3105] = 3066, [3106] = 3106, - [3107] = 2983, - [3108] = 3020, - [3109] = 3029, - [3110] = 2997, - [3111] = 2969, - [3112] = 3005, - [3113] = 3027, - [3114] = 3011, - [3115] = 2982, - [3116] = 3027, - [3117] = 3025, - [3118] = 3118, - [3119] = 3000, - [3120] = 3007, - [3121] = 3023, - [3122] = 3022, - [3123] = 3009, - [3124] = 3010, - [3125] = 3012, - [3126] = 3126, - [3127] = 3127, - [3128] = 3013, - [3129] = 3129, - [3130] = 3008, - [3131] = 2987, - [3132] = 2994, - [3133] = 2983, - [3134] = 2970, - [3135] = 2984, - [3136] = 2997, - [3137] = 2985, - [3138] = 2986, - [3139] = 3005, - [3140] = 3011, - [3141] = 3027, - [3142] = 2998, - [3143] = 3091, - [3144] = 3090, - [3145] = 3145, - [3146] = 3146, - [3147] = 3147, - [3148] = 3148, - [3149] = 3026, - [3150] = 3150, - [3151] = 3151, - [3152] = 3152, - [3153] = 2973, - [3154] = 2974, + [3107] = 3107, + [3108] = 3108, + [3109] = 3060, + [3110] = 3061, + [3111] = 2927, + [3112] = 3051, + [3113] = 3097, + [3114] = 3114, + [3115] = 3074, + [3116] = 3017, + [3117] = 3046, + [3118] = 2933, + [3119] = 3010, + [3120] = 2965, + [3121] = 3036, + [3122] = 3018, + [3123] = 3014, + [3124] = 3008, + [3125] = 3069, + [3126] = 3107, + [3127] = 3101, + [3128] = 3003, + [3129] = 3000, + [3130] = 3037, + [3131] = 2963, + [3132] = 3002, + [3133] = 2998, + [3134] = 2921, + [3135] = 3002, + [3136] = 3071, + [3137] = 3137, + [3138] = 3138, + [3139] = 3071, + [3140] = 3114, + [3141] = 3021, + [3142] = 2985, + [3143] = 2998, + [3144] = 3003, + [3145] = 3082, + [3146] = 3092, + [3147] = 2930, + [3148] = 3138, + [3149] = 3149, + [3150] = 3069, + [3151] = 2994, + [3152] = 2991, + [3153] = 3153, + [3154] = 2962, [3155] = 3155, [3156] = 3156, - [3157] = 3015, - [3158] = 3014, - [3159] = 2975, - [3160] = 2994, + [3157] = 3033, + [3158] = 3070, + [3159] = 3018, + [3160] = 2978, [3161] = 3008, - [3162] = 2987, - [3163] = 3011, - [3164] = 3009, - [3165] = 3165, + [3162] = 2962, + [3163] = 3108, + [3164] = 3052, + [3165] = 3014, [3166] = 3166, [3167] = 3167, [3168] = 3168, - [3169] = 2994, + [3169] = 2386, [3170] = 3170, [3171] = 3171, - [3172] = 3083, - [3173] = 3173, - [3174] = 3174, - [3175] = 3175, - [3176] = 3085, - [3177] = 2981, - [3178] = 3178, - [3179] = 3179, - [3180] = 3180, - [3181] = 3098, - [3182] = 3051, - [3183] = 3061, + [3172] = 2937, + [3173] = 2965, + [3174] = 2961, + [3175] = 3018, + [3176] = 3033, + [3177] = 2959, + [3178] = 2996, + [3179] = 2923, + [3180] = 2924, + [3181] = 2926, + [3182] = 2927, + [3183] = 2929, [3184] = 3184, - [3185] = 3185, - [3186] = 2983, - [3187] = 2970, - [3188] = 3145, - [3189] = 3189, - [3190] = 3190, - [3191] = 3005, - [3192] = 3192, - [3193] = 3192, - [3194] = 3194, - [3195] = 3011, - [3196] = 3196, - [3197] = 3105, - [3198] = 3156, - [3199] = 3106, - [3200] = 3148, - [3201] = 3147, - [3202] = 3027, - [3203] = 3126, - [3204] = 3000, - [3205] = 3118, - [3206] = 2982, - [3207] = 3007, - [3208] = 3127, - [3209] = 3075, - [3210] = 3210, - [3211] = 2984, - [3212] = 3173, - [3213] = 2985, - [3214] = 3190, - [3215] = 2986, - [3216] = 3150, - [3217] = 3155, - [3218] = 3173, - [3219] = 3166, - [3220] = 3180, - [3221] = 3194, - [3222] = 3000, - [3223] = 3173, - [3224] = 3007, - [3225] = 3005, + [3185] = 2930, + [3186] = 3186, + [3187] = 2931, + [3188] = 3188, + [3189] = 2932, + [3190] = 2950, + [3191] = 2933, + [3192] = 2938, + [3193] = 2943, + [3194] = 2949, + [3195] = 2948, + [3196] = 3074, + [3197] = 3197, + [3198] = 2946, + [3199] = 3199, + [3200] = 3200, + [3201] = 2945, + [3202] = 2943, + [3203] = 2935, + [3204] = 3204, + [3205] = 3041, + [3206] = 2942, + [3207] = 3052, + [3208] = 2936, + [3209] = 1492, + [3210] = 3042, + [3211] = 2941, + [3212] = 3170, + [3213] = 2939, + [3214] = 3214, + [3215] = 2963, + [3216] = 3216, + [3217] = 2938, + [3218] = 2938, + [3219] = 2936, + [3220] = 3069, + [3221] = 3221, + [3222] = 2935, + [3223] = 3200, + [3224] = 2933, + [3225] = 2932, [3226] = 3226, - [3227] = 3009, - [3228] = 3010, + [3227] = 2931, + [3228] = 2939, [3229] = 3229, - [3230] = 3230, - [3231] = 3231, - [3232] = 3226, - [3233] = 3233, - [3234] = 3234, - [3235] = 3235, - [3236] = 3236, - [3237] = 3237, - [3238] = 2999, - [3239] = 3189, - [3240] = 3240, - [3241] = 3237, - [3242] = 3231, - [3243] = 3230, - [3244] = 3019, - [3245] = 3167, - [3246] = 3129, - [3247] = 2994, - [3248] = 3012, - [3249] = 3240, - [3250] = 3250, - [3251] = 3251, - [3252] = 3009, - [3253] = 3010, - [3254] = 2983, - [3255] = 3255, - [3256] = 2997, - [3257] = 3257, - [3258] = 2970, - [3259] = 3013, - [3260] = 2983, - [3261] = 2994, - [3262] = 2997, - [3263] = 3263, - [3264] = 3264, - [3265] = 2993, - [3266] = 3266, - [3267] = 3267, - [3268] = 3268, - [3269] = 2992, - [3270] = 3011, + [3230] = 2930, + [3231] = 2923, + [3232] = 3232, + [3233] = 2929, + [3234] = 3026, + [3235] = 2941, + [3236] = 2927, + [3237] = 2926, + [3238] = 3238, + [3239] = 2996, + [3240] = 2929, + [3241] = 3241, + [3242] = 3242, + [3243] = 3243, + [3244] = 13, + [3245] = 2942, + [3246] = 3246, + [3247] = 2943, + [3248] = 2924, + [3249] = 2924, + [3250] = 2926, + [3251] = 2923, + [3252] = 3171, + [3253] = 2936, + [3254] = 3046, + [3255] = 3015, + [3256] = 2945, + [3257] = 2927, + [3258] = 3014, + [3259] = 3052, + [3260] = 3070, + [3261] = 3033, + [3262] = 2961, + [3263] = 2946, + [3264] = 3008, + [3265] = 3265, + [3266] = 2948, + [3267] = 2949, + [3268] = 2945, + [3269] = 2965, + [3270] = 3270, [3271] = 3271, - [3272] = 3229, - [3273] = 3184, - [3274] = 2997, - [3275] = 2983, - [3276] = 3012, - [3277] = 3250, - [3278] = 3236, - [3279] = 3251, - [3280] = 2990, - [3281] = 3013, - [3282] = 2989, - [3283] = 3179, - [3284] = 3178, - [3285] = 3285, - [3286] = 3285, - [3287] = 3235, + [3272] = 2972, + [3273] = 2987, + [3274] = 2981, + [3275] = 2972, + [3276] = 2953, + [3277] = 2950, + [3278] = 3278, + [3279] = 3046, + [3280] = 3280, + [3281] = 3281, + [3282] = 3241, + [3283] = 2978, + [3284] = 3108, + [3285] = 2937, + [3286] = 2933, + [3287] = 2999, [3288] = 3288, - [3289] = 3234, - [3290] = 3233, + [3289] = 3289, + [3290] = 3003, [3291] = 3291, - [3292] = 2988, - [3293] = 3175, - [3294] = 3174, - [3295] = 3173, - [3296] = 3288, - [3297] = 3297, - [3298] = 2997, - [3299] = 3299, + [3292] = 3292, + [3293] = 3293, + [3294] = 3294, + [3295] = 3153, + [3296] = 3296, + [3297] = 3071, + [3298] = 3298, + [3299] = 3002, [3300] = 3300, - [3301] = 2987, - [3302] = 3008, - [3303] = 3303, - [3304] = 2997, - [3305] = 3171, - [3306] = 3299, - [3307] = 3291, - [3308] = 3170, - [3309] = 3268, - [3310] = 3027, - [3311] = 3266, - [3312] = 3168, - [3313] = 3313, - [3314] = 3314, - [3315] = 3315, + [3301] = 2994, + [3302] = 3302, + [3303] = 2998, + [3304] = 3002, + [3305] = 3188, + [3306] = 3003, + [3307] = 3156, + [3308] = 2932, + [3309] = 2936, + [3310] = 2921, + [3311] = 3311, + [3312] = 3008, + [3313] = 3014, + [3314] = 2998, + [3315] = 3069, [3316] = 3316, [3317] = 3317, + [3318] = 3278, + [3319] = 2956, + [3320] = 3018, + [3321] = 2931, + [3322] = 3051, + [3323] = 2946, + [3324] = 3216, + [3325] = 3325, + [3326] = 2963, + [3327] = 3096, + [3328] = 3066, + [3329] = 3067, + [3330] = 2972, + [3331] = 2963, + [3332] = 3332, + [3333] = 2948, + [3334] = 3046, + [3335] = 3311, + [3336] = 3243, + [3337] = 3337, + [3338] = 2980, + [3339] = 3339, + [3340] = 3051, + [3341] = 3061, + [3342] = 3076, + [3343] = 2996, + [3344] = 3066, + [3345] = 3067, + [3346] = 3043, + [3347] = 3073, + [3348] = 3051, + [3349] = 3076, + [3350] = 3061, + [3351] = 3351, + [3352] = 3352, + [3353] = 3071, + [3354] = 3061, + [3355] = 3355, + [3356] = 2950, + [3357] = 2929, + [3358] = 3066, + [3359] = 2949, + [3360] = 3360, + [3361] = 3076, + [3362] = 3073, + [3363] = 3067, + [3364] = 3015, + [3365] = 3106, + [3366] = 3033, + [3367] = 3052, + [3368] = 3026, + [3369] = 3057, + [3370] = 3149, + [3371] = 3058, + [3372] = 3073, + [3373] = 3074, + [3374] = 3238, + [3375] = 3375, + [3376] = 3376, + [3377] = 3377, + [3378] = 3378, + [3379] = 3379, + [3380] = 3380, + [3381] = 3381, + [3382] = 3382, + [3383] = 3383, + [3384] = 3384, + [3385] = 3385, + [3386] = 3386, + [3387] = 3387, + [3388] = 3388, + [3389] = 3389, + [3390] = 3390, + [3391] = 3391, + [3392] = 3392, + [3393] = 3393, + [3394] = 3377, + [3395] = 3395, + [3396] = 3396, + [3397] = 3397, + [3398] = 3398, + [3399] = 3399, + [3400] = 3400, + [3401] = 3401, + [3402] = 3402, + [3403] = 3403, + [3404] = 3404, + [3405] = 3405, + [3406] = 3406, + [3407] = 3407, + [3408] = 3408, + [3409] = 3409, + [3410] = 3410, + [3411] = 3411, + [3412] = 3412, + [3413] = 3413, + [3414] = 3414, + [3415] = 3415, + [3416] = 3416, + [3417] = 3417, + [3418] = 3418, + [3419] = 3419, + [3420] = 3420, + [3421] = 3421, + [3422] = 3422, + [3423] = 3423, + [3424] = 3424, + [3425] = 3425, + [3426] = 3426, + [3427] = 3427, + [3428] = 3428, + [3429] = 3429, + [3430] = 3430, + [3431] = 3407, + [3432] = 3432, + [3433] = 3419, + [3434] = 3411, + [3435] = 3435, + [3436] = 3436, + [3437] = 3398, + [3438] = 3438, + [3439] = 3439, + [3440] = 3414, + [3441] = 3406, + [3442] = 3376, + [3443] = 3443, + [3444] = 3444, + [3445] = 3445, + [3446] = 3446, + [3447] = 3376, + [3448] = 3406, + [3449] = 3449, + [3450] = 3450, + [3451] = 3451, + [3452] = 3414, + [3453] = 3453, + [3454] = 3407, + [3455] = 3398, + [3456] = 3456, + [3457] = 3457, + [3458] = 3458, + [3459] = 3459, + [3460] = 3409, + [3461] = 3428, + [3462] = 3462, + [3463] = 3428, + [3464] = 3387, + [3465] = 3465, + [3466] = 3466, + [3467] = 3385, + [3468] = 3425, + [3469] = 3424, + [3470] = 3470, + [3471] = 3423, + [3472] = 3378, + [3473] = 3379, + [3474] = 3421, + [3475] = 3475, + [3476] = 3476, + [3477] = 3477, + [3478] = 3478, + [3479] = 3408, + [3480] = 3402, + [3481] = 3481, + [3482] = 3482, + [3483] = 3483, + [3484] = 3411, + [3485] = 3409, + [3486] = 3408, + [3487] = 3487, + [3488] = 3488, + [3489] = 3489, + [3490] = 3490, + [3491] = 3405, + [3492] = 3404, + [3493] = 3493, + [3494] = 3403, + [3495] = 3495, + [3496] = 3401, + [3497] = 3497, + [3498] = 3498, + [3499] = 3400, + [3500] = 3500, + [3501] = 3501, + [3502] = 3382, + [3503] = 3410, + [3504] = 3504, + [3505] = 3458, + [3506] = 3451, + [3507] = 3507, + [3508] = 3377, + [3509] = 3509, + [3510] = 3510, + [3511] = 3445, + [3512] = 3512, + [3513] = 3513, + [3514] = 3514, + [3515] = 3515, + [3516] = 3516, + [3517] = 3517, + [3518] = 3518, + [3519] = 3439, + [3520] = 3520, + [3521] = 3446, + [3522] = 3436, + [3523] = 3490, + [3524] = 3524, + [3525] = 3525, + [3526] = 3526, + [3527] = 3401, + [3528] = 3528, + [3529] = 3403, + [3530] = 3530, + [3531] = 3531, + [3532] = 3532, + [3533] = 3533, + [3534] = 3534, + [3535] = 3404, + [3536] = 3422, + [3537] = 3405, + [3538] = 3538, + [3539] = 3539, + [3540] = 3516, + [3541] = 3510, + [3542] = 3408, + [3543] = 3513, + [3544] = 3409, + [3545] = 3429, + [3546] = 3411, + [3547] = 3482, + [3548] = 3426, + [3549] = 3379, + [3550] = 3550, + [3551] = 3481, + [3552] = 3552, + [3553] = 3378, + [3554] = 3554, + [3555] = 3555, + [3556] = 3402, + [3557] = 3557, + [3558] = 3436, + [3559] = 3381, + [3560] = 3560, + [3561] = 3561, + [3562] = 3417, + [3563] = 3421, + [3564] = 3564, + [3565] = 3423, + [3566] = 3424, + [3567] = 3425, + [3568] = 3410, + [3569] = 3528, + [3570] = 3514, + [3571] = 3444, + [3572] = 3428, + [3573] = 3573, + [3574] = 3574, + [3575] = 3575, + [3576] = 3576, + [3577] = 3577, + [3578] = 3578, + [3579] = 3579, + [3580] = 3398, + [3581] = 3407, + [3582] = 3582, + [3583] = 3414, + [3584] = 3406, + [3585] = 3376, + [3586] = 3586, + [3587] = 3587, + [3588] = 3402, + [3589] = 3376, + [3590] = 3590, + [3591] = 3591, + [3592] = 3504, + [3593] = 3493, + [3594] = 3594, + [3595] = 3414, + [3596] = 3406, + [3597] = 3407, + [3598] = 3398, + [3599] = 3410, + [3600] = 3412, + [3601] = 3601, + [3602] = 3427, + [3603] = 3603, + [3604] = 3604, + [3605] = 3579, + [3606] = 3413, + [3607] = 3393, + [3608] = 3538, + [3609] = 3609, + [3610] = 3610, + [3611] = 3611, + [3612] = 1495, + [3613] = 3417, + [3614] = 3614, + [3615] = 3378, + [3616] = 3379, + [3617] = 3617, + [3618] = 3618, + [3619] = 3422, + [3620] = 3620, + [3621] = 3560, + [3622] = 3622, + [3623] = 3623, + [3624] = 3396, + [3625] = 3590, + [3626] = 3428, + [3627] = 3426, + [3628] = 3628, + [3629] = 3629, + [3630] = 3630, + [3631] = 3631, + [3632] = 3429, + [3633] = 3633, + [3634] = 3634, + [3635] = 3635, + [3636] = 3636, + [3637] = 3637, + [3638] = 3425, + [3639] = 3424, + [3640] = 3640, + [3641] = 3377, + [3642] = 3423, + [3643] = 3643, + [3644] = 3577, + [3645] = 3421, + [3646] = 3646, + [3647] = 3456, + [3648] = 3377, + [3649] = 3405, + [3650] = 3526, + [3651] = 3525, + [3652] = 3652, + [3653] = 3404, + [3654] = 3402, + [3655] = 3630, + [3656] = 3656, + [3657] = 3604, + [3658] = 3410, + [3659] = 3417, + [3660] = 3417, + [3661] = 3661, + [3662] = 3422, + [3663] = 3531, + [3664] = 3426, + [3665] = 3429, + [3666] = 3666, + [3667] = 3667, + [3668] = 3668, + [3669] = 3404, + [3670] = 3462, + [3671] = 3405, + [3672] = 3449, + [3673] = 3634, + [3674] = 3401, + [3675] = 3439, + [3676] = 3676, + [3677] = 3404, + [3678] = 3411, + [3679] = 3405, + [3680] = 3409, + [3681] = 3421, + [3682] = 3682, + [3683] = 3408, + [3684] = 3684, + [3685] = 3685, + [3686] = 3686, + [3687] = 3687, + [3688] = 3450, + [3689] = 3689, + [3690] = 3690, + [3691] = 3691, + [3692] = 3490, + [3693] = 3405, + [3694] = 3591, + [3695] = 3629, + [3696] = 3423, + [3697] = 3404, + [3698] = 3652, + [3699] = 3699, + [3700] = 3424, + [3701] = 3661, + [3702] = 3702, + [3703] = 3691, + [3704] = 3704, + [3705] = 3578, + [3706] = 3555, + [3707] = 3498, + [3708] = 3388, + [3709] = 3709, + [3710] = 3395, + [3711] = 3711, + [3712] = 3690, + [3713] = 3713, + [3714] = 3403, + [3715] = 3520, + [3716] = 3716, + [3717] = 3617, + [3718] = 3623, + [3719] = 3401, + [3720] = 3636, + [3721] = 3721, + [3722] = 3418, + [3723] = 3379, + [3724] = 3724, + [3725] = 3601, + [3726] = 3425, + [3727] = 3426, + [3728] = 3689, + [3729] = 3729, + [3730] = 3436, + [3731] = 3716, + [3732] = 3438, + [3733] = 3400, + [3734] = 3689, + [3735] = 3403, + [3736] = 3689, + [3737] = 3429, + [3738] = 3738, + [3739] = 3689, + [3740] = 3426, + [3741] = 3741, + [3742] = 3426, + [3743] = 3417, + [3744] = 3689, + [3745] = 3426, + [3746] = 3417, + [3747] = 3426, + [3748] = 3439, + [3749] = 3377, + [3750] = 3750, + [3751] = 3402, + [3752] = 3417, + [3753] = 3620, + [3754] = 3524, + [3755] = 3552, + [3756] = 3415, + [3757] = 3757, + [3758] = 3422, + [3759] = 3759, + [3760] = 3586, + [3761] = 3534, + [3762] = 3518, + [3763] = 3515, + [3764] = 3459, + [3765] = 3750, + [3766] = 3426, + [3767] = 3429, + [3768] = 3768, + [3769] = 3769, + [3770] = 3582, + [3771] = 3771, + [3772] = 3512, + [3773] = 3635, + [3774] = 3436, + [3775] = 3378, + [3776] = 3439, + [3777] = 3777, + [3778] = 3778, + [3779] = 3687, + [3780] = 3780, + [3781] = 3781, + [3782] = 3782, + [3783] = 3377, + [3784] = 3686, + [3785] = 3702, + [3786] = 3704, + [3787] = 3402, + [3788] = 3417, + [3789] = 3422, + [3790] = 3422, + [3791] = 3771, + [3792] = 3792, + [3793] = 3426, + [3794] = 3685, + [3795] = 3429, + [3796] = 3633, + [3797] = 3622, + [3798] = 3618, + [3799] = 3614, + [3800] = 3643, + [3801] = 3667, + [3802] = 3802, + [3803] = 3802, + [3804] = 3804, + [3805] = 3637, + [3806] = 3806, + [3807] = 3807, + [3808] = 3808, + [3809] = 3780, + [3810] = 3810, + [3811] = 3811, + [3812] = 3812, + [3813] = 3813, }; static bool ts_lex(TSLexer *lexer, TSStateId state) { @@ -6192,67 +6917,67 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(645); + if (eof) ADVANCE(737); if (lookahead == ' ') ADVANCE(28); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(669); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1181); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == 'L') ADVANCE(693); - if (lookahead == 'N') ADVANCE(699); - if (lookahead == 'S') ADVANCE(688); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'l') ADVANCE(713); - if (lookahead == 'n') ADVANCE(801); - if (lookahead == 's') ADVANCE(803); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(761); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1351); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == 'B') ADVANCE(808); + if (lookahead == 'L') ADVANCE(788); + if (lookahead == 'N') ADVANCE(794); + if (lookahead == 'S') ADVANCE(783); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'b') ADVANCE(911); + if (lookahead == 'l') ADVANCE(809); + if (lookahead == 'n') ADVANCE(914); + if (lookahead == 's') ADVANCE(916); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(757); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(804); + lookahead == 'a') ADVANCE(862); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(714); + lookahead == 'c') ADVANCE(810); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(806); + lookahead == 'd') ADVANCE(811); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(720); + lookahead == 'e') ADVANCE(812); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(899); + lookahead == 'f') ADVANCE(1027); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(807); + lookahead == 'g') ADVANCE(917); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(963); + lookahead == 'i') ADVANCE(1095); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(715); + lookahead == 'm') ADVANCE(813); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(877); + lookahead == 'o') ADVANCE(999); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(727); + lookahead == 'p') ADVANCE(823); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1141); + lookahead == 'q') ADVANCE(1307); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(769); + lookahead == 'r') ADVANCE(874); if (lookahead == 'T' || - lookahead == 't') ADVANCE(809); + lookahead == 't') ADVANCE(981); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(985); + lookahead == 'u') ADVANCE(1116); if (lookahead == 'V' || - lookahead == 'v') ADVANCE(729); + lookahead == 'v') ADVANCE(827); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(890); + lookahead == 'w') ADVANCE(1017); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(27); @@ -6260,105 +6985,105 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(0) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 1: - if (lookahead == '\n') ADVANCE(1199); + if (lookahead == '\n') ADVANCE(1369); if (lookahead == '\r') ADVANCE(2); - if (lookahead == ' ') ADVANCE(1198); + if (lookahead == ' ') ADVANCE(1368); END_STATE(); case 2: - if (lookahead == '\n') ADVANCE(1200); + if (lookahead == '\n') ADVANCE(1370); END_STATE(); case 3: - if (lookahead == '\n') ADVANCE(1196); + if (lookahead == '\n') ADVANCE(1366); if (lookahead == '\r') ADVANCE(4); - if (lookahead == ' ') ADVANCE(1195); + if (lookahead == ' ') ADVANCE(1365); END_STATE(); case 4: - if (lookahead == '\n') ADVANCE(1197); + if (lookahead == '\n') ADVANCE(1367); END_STATE(); case 5: - if (lookahead == '\n') SKIP(42) + if (lookahead == '\n') SKIP(44) END_STATE(); case 6: - if (lookahead == '\n') SKIP(42) + if (lookahead == '\n') SKIP(44) if (lookahead == '\r') SKIP(5) END_STATE(); case 7: - if (lookahead == '\n') SKIP(44) + if (lookahead == '\n') SKIP(46) END_STATE(); case 8: - if (lookahead == '\n') SKIP(44) + if (lookahead == '\n') SKIP(46) if (lookahead == '\r') SKIP(7) END_STATE(); case 9: - if (lookahead == '\n') SKIP(46) + if (lookahead == '\n') SKIP(48) END_STATE(); case 10: - if (lookahead == '\n') SKIP(46) + if (lookahead == '\n') SKIP(48) if (lookahead == '\r') SKIP(9) END_STATE(); case 11: - if (lookahead == '\n') SKIP(36) + if (lookahead == '\n') SKIP(58) END_STATE(); case 12: - if (lookahead == '\n') SKIP(36) + if (lookahead == '\n') SKIP(58) if (lookahead == '\r') SKIP(11) END_STATE(); case 13: - if (lookahead == '\n') SKIP(48) + if (lookahead == '\n') SKIP(93) END_STATE(); case 14: - if (lookahead == '\n') SKIP(48) + if (lookahead == '\n') SKIP(93) if (lookahead == '\r') SKIP(13) END_STATE(); case 15: - if (lookahead == '\n') SKIP(60) + if (lookahead == '\n') SKIP(55) + if (lookahead == '\r') ADVANCE(1358); + if (lookahead != 0) ADVANCE(1358); END_STATE(); case 16: - if (lookahead == '\n') SKIP(60) - if (lookahead == '\r') SKIP(15) + if (lookahead == '\n') SKIP(57) + if (lookahead == '\r') ADVANCE(1358); + if (lookahead != 0) ADVANCE(1358); END_STATE(); case 17: - if (lookahead == '\n') SKIP(55) - if (lookahead == '\r') ADVANCE(1188); - if (lookahead != 0) ADVANCE(1188); + if (lookahead == '\n') SKIP(43) END_STATE(); case 18: - if (lookahead == '\n') SKIP(57) - if (lookahead == '\r') ADVANCE(1188); - if (lookahead != 0) ADVANCE(1188); + if (lookahead == '\n') SKIP(43) + if (lookahead == '\r') SKIP(17) END_STATE(); case 19: - if (lookahead == '\n') SKIP(41) + if (lookahead == '\n') SKIP(91) END_STATE(); case 20: - if (lookahead == '\n') SKIP(41) + if (lookahead == '\n') SKIP(91) if (lookahead == '\r') SKIP(19) END_STATE(); case 21: - if (lookahead == '\n') ADVANCE(64); - if (lookahead == '\r') ADVANCE(22); - if (lookahead == '*') ADVANCE(662); - if (lookahead != 0) ADVANCE(65); + if (lookahead == '\n') SKIP(110) END_STATE(); case 22: - if (lookahead == '\n') ADVANCE(64); - if (lookahead == '*') ADVANCE(662); - if (lookahead != 0) ADVANCE(65); + if (lookahead == '\n') SKIP(110) + if (lookahead == '\r') SKIP(21) + if (lookahead == '.') ADVANCE(137); + if (('-' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(95); END_STATE(); case 23: - if (lookahead == '\n') SKIP(102) + if (lookahead == '\n') ADVANCE(64); + if (lookahead == '\r') ADVANCE(24); + if (lookahead == '*') ADVANCE(754); + if (lookahead != 0) ADVANCE(65); END_STATE(); case 24: - if (lookahead == '\n') SKIP(102) - if (lookahead == '\r') SKIP(23) - if (lookahead == '.') ADVANCE(127); - if (('-' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(89); + if (lookahead == '\n') ADVANCE(64); + if (lookahead == '*') ADVANCE(754); + if (lookahead != 0) ADVANCE(65); END_STATE(); case 25: if (lookahead == '\n') SKIP(29) @@ -6369,65 +7094,65 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 27: if (lookahead == ' ') ADVANCE(28); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(669); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1181); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == 'L') ADVANCE(693); - if (lookahead == 'N') ADVANCE(699); - if (lookahead == 'S') ADVANCE(688); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'l') ADVANCE(713); - if (lookahead == 'n') ADVANCE(801); - if (lookahead == 's') ADVANCE(803); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(761); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1351); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == 'B') ADVANCE(808); + if (lookahead == 'L') ADVANCE(788); + if (lookahead == 'N') ADVANCE(794); + if (lookahead == 'S') ADVANCE(783); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'b') ADVANCE(911); + if (lookahead == 'l') ADVANCE(809); + if (lookahead == 'n') ADVANCE(914); + if (lookahead == 's') ADVANCE(916); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(757); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(804); + lookahead == 'a') ADVANCE(862); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(714); + lookahead == 'c') ADVANCE(810); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(806); + lookahead == 'd') ADVANCE(811); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(720); + lookahead == 'e') ADVANCE(812); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(899); + lookahead == 'f') ADVANCE(1027); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(807); + lookahead == 'g') ADVANCE(917); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(963); + lookahead == 'i') ADVANCE(1095); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(715); + lookahead == 'm') ADVANCE(813); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(877); + lookahead == 'o') ADVANCE(999); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(727); + lookahead == 'p') ADVANCE(823); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1141); + lookahead == 'q') ADVANCE(1307); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(769); + lookahead == 'r') ADVANCE(874); if (lookahead == 'T' || - lookahead == 't') ADVANCE(809); + lookahead == 't') ADVANCE(981); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(985); + lookahead == 'u') ADVANCE(1116); if (lookahead == 'V' || - lookahead == 'v') ADVANCE(729); + lookahead == 'v') ADVANCE(827); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(890); + lookahead == 'w') ADVANCE(1017); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(27); @@ -6435,70 +7160,70 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(27) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 28: if (lookahead == ' ') ADVANCE(28); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(669); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1181); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == 'L') ADVANCE(693); - if (lookahead == 'N') ADVANCE(699); - if (lookahead == 'S') ADVANCE(688); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'l') ADVANCE(713); - if (lookahead == 'n') ADVANCE(801); - if (lookahead == 's') ADVANCE(803); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(761); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1351); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == 'B') ADVANCE(808); + if (lookahead == 'L') ADVANCE(788); + if (lookahead == 'N') ADVANCE(794); + if (lookahead == 'S') ADVANCE(783); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'b') ADVANCE(911); + if (lookahead == 'l') ADVANCE(809); + if (lookahead == 'n') ADVANCE(914); + if (lookahead == 's') ADVANCE(916); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(757); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(804); + lookahead == 'a') ADVANCE(862); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(714); + lookahead == 'c') ADVANCE(810); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(806); + lookahead == 'd') ADVANCE(811); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(720); + lookahead == 'e') ADVANCE(812); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(899); + lookahead == 'f') ADVANCE(1027); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(807); + lookahead == 'g') ADVANCE(917); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(963); + lookahead == 'i') ADVANCE(1095); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(715); + lookahead == 'm') ADVANCE(813); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(876); + lookahead == 'o') ADVANCE(998); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(727); + lookahead == 'p') ADVANCE(823); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1141); + lookahead == 'q') ADVANCE(1307); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(769); + lookahead == 'r') ADVANCE(874); if (lookahead == 'T' || - lookahead == 't') ADVANCE(809); + lookahead == 't') ADVANCE(981); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(985); + lookahead == 'u') ADVANCE(1116); if (lookahead == 'V' || - lookahead == 'v') ADVANCE(729); + lookahead == 'v') ADVANCE(827); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(890); + lookahead == 'w') ADVANCE(1017); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(27); @@ -6506,66 +7231,66 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(27) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 29: if (lookahead == ' ') ADVANCE(30); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(115); - if (lookahead == 'S') ADVANCE(103); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'L') ADVANCE(118); + if (lookahead == 'N') ADVANCE(124); + if (lookahead == 'S') ADVANCE(112); if (lookahead == '\\') SKIP(26) - if (lookahead == 'n') ADVANCE(250); - if (lookahead == 's') ADVANCE(253); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == 'l') ADVANCE(138); + if (lookahead == 'n') ADVANCE(288); + if (lookahead == 's') ADVANCE(291); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(178); + lookahead == 'a') ADVANCE(201); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(256); + lookahead == 'b') ADVANCE(305); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(128); + lookahead == 'c') ADVANCE(139); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(140); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(133); + lookahead == 'e') ADVANCE(141); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(339); + lookahead == 'f') ADVANCE(391); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(415); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(129); + lookahead == 'i') ADVANCE(476); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(146); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(315); + lookahead == 'o') ADVANCE(362); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(141); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(598); + lookahead == 'p') ADVANCE(152); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(194); + lookahead == 'r') ADVANCE(219); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(387); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(439); + lookahead == 'u') ADVANCE(503); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(534); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(331); + lookahead == 'w') ADVANCE(381); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(29); @@ -6573,65 +7298,65 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(29) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); END_STATE(); case 30: if (lookahead == ' ') ADVANCE(30); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(115); - if (lookahead == 'S') ADVANCE(103); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'L') ADVANCE(118); + if (lookahead == 'N') ADVANCE(124); + if (lookahead == 'S') ADVANCE(112); if (lookahead == '\\') SKIP(26) - if (lookahead == 'n') ADVANCE(250); - if (lookahead == 's') ADVANCE(253); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == 'l') ADVANCE(138); + if (lookahead == 'n') ADVANCE(288); + if (lookahead == 's') ADVANCE(291); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(179); + lookahead == 'a') ADVANCE(203); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(256); + lookahead == 'b') ADVANCE(305); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(128); + lookahead == 'c') ADVANCE(139); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(140); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(133); + lookahead == 'e') ADVANCE(141); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(339); + lookahead == 'f') ADVANCE(391); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(415); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(129); + lookahead == 'i') ADVANCE(476); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(146); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(314); + lookahead == 'o') ADVANCE(361); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(141); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(598); + lookahead == 'p') ADVANCE(152); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(194); + lookahead == 'r') ADVANCE(219); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(387); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(439); + lookahead == 'u') ADVANCE(503); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(534); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(331); + lookahead == 'w') ADVANCE(381); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(29); @@ -6639,45 +7364,45 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(29) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); END_STATE(); case 31: if (lookahead == ' ') ADVANCE(31); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1004); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(802); + lookahead == 'n') ADVANCE(915); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1053); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(32); @@ -6685,42 +7410,42 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(32) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 32: if (lookahead == ' ') ADVANCE(31); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(802); + lookahead == 'n') ADVANCE(915); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(32); @@ -6728,45 +7453,45 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(32) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 33: if (lookahead == ' ') ADVANCE(33); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == 'N') ADVANCE(703); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'n') ADVANCE(802); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == 'N') ADVANCE(798); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(915); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1004); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1053); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(34); @@ -6774,41 +7499,41 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(34) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 34: if (lookahead == ' ') ADVANCE(33); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == 'N') ADVANCE(703); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'n') ADVANCE(802); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == 'N') ADVANCE(798); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(915); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(34); @@ -6816,149 +7541,129 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(34) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 35: if (lookahead == ' ') ADVANCE(35); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'L') ADVANCE(110); - if (lookahead == 'N') ADVANCE(119); - if (lookahead == '\\') SKIP(12) - if (lookahead == 'l') ADVANCE(163); - if (lookahead == 'n') ADVANCE(252); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(451); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(470); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(257); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(504); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(361); + lookahead == 'f') ADVANCE(1238); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(445); + lookahead == 'g') ADVANCE(918); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(132); + lookahead == 'm') ADVANCE(842); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(946); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(511); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(270); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(600); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(488); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\r') ADVANCE(36); - if (lookahead == '\f' || + lookahead == '\f' || + lookahead == '\r' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(36) + if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 36: if (lookahead == ' ') ADVANCE(35); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'L') ADVANCE(110); - if (lookahead == 'N') ADVANCE(119); - if (lookahead == '\\') SKIP(12) - if (lookahead == 'l') ADVANCE(163); - if (lookahead == 'n') ADVANCE(252); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(617); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(470); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(257); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(504); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(361); + lookahead == 'f') ADVANCE(1238); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(445); + lookahead == 'g') ADVANCE(918); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(132); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(270); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(600); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(488); + lookahead == 'm') ADVANCE(842); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(946); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\r') ADVANCE(36); - if (lookahead == '\f' || + lookahead == '\f' || + lookahead == '\r' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(36) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 37: if (lookahead == ' ') ADVANCE(37); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(1225); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(1395); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1004); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(835); + lookahead == 'n') ADVANCE(946); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1053); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -6966,38 +7671,38 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(38) - if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 38: if (lookahead == ' ') ADVANCE(37); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(1225); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(1395); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(835); + lookahead == 'n') ADVANCE(946); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7005,43 +7710,43 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(38) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 39: if (lookahead == ' ') ADVANCE(39); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(1225); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(704); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'n') ADVANCE(835); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(1395); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'N') ADVANCE(799); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(946); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1004); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1053); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(40); @@ -7049,39 +7754,39 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(40) - if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('D' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 40: if (lookahead == ' ') ADVANCE(39); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(1225); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(704); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == 'n') ADVANCE(835); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(1395); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'N') ADVANCE(799); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(946); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(805); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1039); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1051); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(808); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(800); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(744); + lookahead == 'm') ADVANCE(842); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(40); @@ -7089,186 +7794,154 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(40) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 41: - if (lookahead == ' ') ADVANCE(1328); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') SKIP(20) - if (lookahead == '{') ADVANCE(664); - if (lookahead == '\t' || - lookahead == '\n' || - lookahead == '\f' || - lookahead == '\r' || - lookahead == 8203 || - lookahead == 8288 || - lookahead == 65279) SKIP(41) - END_STATE(); - case 42: - if (lookahead == ' ') ADVANCE(43); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'S') ADVANCE(104); - if (lookahead == '\\') SKIP(6) - if (lookahead == 's') ADVANCE(329); - if (lookahead == '{') ADVANCE(664); + if (lookahead == ' ') ADVANCE(41); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'N') ADVANCE(799); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(946); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(438); + lookahead == 'a') ADVANCE(1143); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(256); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(172); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(387); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(359); + lookahead == 'f') ADVANCE(1238); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(251); + lookahead == 'm') ADVANCE(842); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(312); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(193); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(558); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(338); + lookahead == 'o') ADVANCE(1201); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\r') ADVANCE(42); - if (lookahead == '\f' || + lookahead == '\f' || + lookahead == '\r' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(42) + if (('H' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 43: - if (lookahead == ' ') ADVANCE(43); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'S') ADVANCE(104); - if (lookahead == '\\') SKIP(6) - if (lookahead == 's') ADVANCE(329); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(440); + case 42: + if (lookahead == ' ') ADVANCE(41); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '/') ADVANCE(755); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'N') ADVANCE(799); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == 'n') ADVANCE(946); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(256); + lookahead == 'b') ADVANCE(912); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(172); + lookahead == 'c') ADVANCE(1179); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(387); + lookahead == 'e') ADVANCE(1198); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(359); + lookahead == 'f') ADVANCE(1238); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'g') ADVANCE(918); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(913); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(251); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(313); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(193); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(558); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(338); + lookahead == 'm') ADVANCE(842); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\r') ADVANCE(42); - if (lookahead == '\f' || + lookahead == '\f' || + lookahead == '\r' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(42) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); + END_STATE(); + case 43: + if (lookahead == ' ') ADVANCE(1519); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') SKIP(18) + if (lookahead == '{') ADVANCE(756); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(43) END_STATE(); case 44: if (lookahead == ' ') ADVANCE(45); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') SKIP(8) - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'B') ADVANCE(136); + if (lookahead == 'S') ADVANCE(113); + if (lookahead == '\\') SKIP(6) + if (lookahead == 'b') ADVANCE(304); + if (lookahead == 's') ADVANCE(292); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(438); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'a') ADVANCE(200); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(468); + lookahead == 'c') ADVANCE(189); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(387); + lookahead == 'e') ADVANCE(446); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(473); + lookahead == 'f') ADVANCE(395); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'i') ADVANCE(477); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(145); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(251); + lookahead == 'n') ADVANCE(289); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(311); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(329); + lookahead == 'o') ADVANCE(359); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(218); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(387); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(558); + lookahead == 'u') ADVANCE(624); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(338); + lookahead == 'w') ADVANCE(390); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(44); @@ -7279,52 +7952,54 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 45: if (lookahead == ' ') ADVANCE(45); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1281); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') SKIP(8) - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'B') ADVANCE(136); + if (lookahead == 'S') ADVANCE(113); + if (lookahead == '\\') SKIP(6) + if (lookahead == 'b') ADVANCE(304); + if (lookahead == 's') ADVANCE(292); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(440); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'a') ADVANCE(202); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(468); + lookahead == 'c') ADVANCE(189); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(387); + lookahead == 'e') ADVANCE(446); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(473); + lookahead == 'f') ADVANCE(395); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'i') ADVANCE(477); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(145); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(251); + lookahead == 'n') ADVANCE(289); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(316); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(329); + lookahead == 'o') ADVANCE(360); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(218); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(387); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(558); + lookahead == 'u') ADVANCE(624); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(338); + lookahead == 'w') ADVANCE(390); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(44); @@ -7335,46 +8010,54 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 46: if (lookahead == ' ') ADVANCE(47); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(119); - if (lookahead == '\\') SKIP(10) - if (lookahead == 'n') ADVANCE(252); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') SKIP(8) + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(438); + lookahead == 'a') ADVANCE(501); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'b') ADVANCE(304); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(468); + lookahead == 'c') ADVANCE(533); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(386); + lookahead == 'e') ADVANCE(445); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(473); + lookahead == 'f') ADVANCE(413); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'i') ADVANCE(507); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(145); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(289); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(312); + lookahead == 'o') ADVANCE(358); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(702); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(380); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(386); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(637); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(390); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(46); @@ -7385,46 +8068,54 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 47: if (lookahead == ' ') ADVANCE(47); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(119); - if (lookahead == '\\') SKIP(10) - if (lookahead == 'n') ADVANCE(252); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1467); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == '\\') SKIP(8) + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(440); + lookahead == 'a') ADVANCE(504); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'b') ADVANCE(304); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(468); + lookahead == 'c') ADVANCE(533); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(386); + lookahead == 'e') ADVANCE(445); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(473); + lookahead == 'f') ADVANCE(413); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(442); + lookahead == 'i') ADVANCE(507); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); + lookahead == 'm') ADVANCE(145); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(289); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(313); + lookahead == 'o') ADVANCE(363); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(702); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(380); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); + lookahead == 't') ADVANCE(386); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(637); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(390); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r') ADVANCE(46); @@ -7435,115 +8126,121 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 48: if (lookahead == ' ') ADVANCE(49); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1181); - if (lookahead == '/') ADVANCE(663); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') SKIP(14) - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'B') ADVANCE(136); + if (lookahead == 'N') ADVANCE(128); + if (lookahead == '\\') SKIP(10) + if (lookahead == 'b') ADVANCE(304); + if (lookahead == 'n') ADVANCE(290); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(438); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'a') ADVANCE(501); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(169); + lookahead == 'c') ADVANCE(533); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(466); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(503); + lookahead == 'e') ADVANCE(447); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(485); + lookahead == 'f') ADVANCE(416); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(443); + lookahead == 'i') ADVANCE(507); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(228); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(249); + lookahead == 'm') ADVANCE(145); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(311); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(536); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(275); + lookahead == 'o') ADVANCE(359); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(665); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(387); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\f' || - lookahead == '\r' || + lookahead == '\r') ADVANCE(48); + if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(48) END_STATE(); case 49: if (lookahead == ' ') ADVANCE(49); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1181); - if (lookahead == '/') ADVANCE(663); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == '\\') SKIP(14) - if (lookahead == '{') ADVANCE(664); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'B') ADVANCE(136); + if (lookahead == 'N') ADVANCE(128); + if (lookahead == '\\') SKIP(10) + if (lookahead == 'b') ADVANCE(304); + if (lookahead == 'n') ADVANCE(290); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(440); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(255); + lookahead == 'a') ADVANCE(504); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(169); + lookahead == 'c') ADVANCE(533); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(466); + lookahead == 'd') ADVANCE(316); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(503); + lookahead == 'e') ADVANCE(447); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(485); + lookahead == 'f') ADVANCE(416); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); + lookahead == 'g') ADVANCE(264); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(443); + lookahead == 'i') ADVANCE(507); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(228); + lookahead == 'l') ADVANCE(179); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(249); + lookahead == 'm') ADVANCE(145); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(316); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(536); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(275); + lookahead == 'o') ADVANCE(360); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(665); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(387); if (lookahead == '\t' || lookahead == '\n' || - lookahead == '\f' || - lookahead == '\r' || + lookahead == '\r') ADVANCE(48); + if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(48) END_STATE(); case 50: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '&') ADVANCE(1225); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '.') ADVANCE(1179); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '&') ADVANCE(1395); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '.') ADVANCE(1349); if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || @@ -7552,35 +8249,35 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == '\n' || lookahead == '\r' || lookahead == ' ') ADVANCE(50); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 51: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '-') ADVANCE(1201); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '-') ADVANCE(1371); if (lookahead == '/') ADVANCE(63); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1158); + lookahead == 'a') ADVANCE(1326); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1037); + lookahead == 'c') ADVANCE(1182); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1010); + lookahead == 'i') ADVANCE(1152); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(756); + lookahead == 'm') ADVANCE(861); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(842); + lookahead == 'n') ADVANCE(954); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1140); + lookahead == 'o') ADVANCE(1308); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1139); + lookahead == 's') ADVANCE(1306); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1040); + lookahead == 't') ADVANCE(1184); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7589,33 +8286,33 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(51) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('B' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('B' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 52: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '-') ADVANCE(1201); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '-') ADVANCE(1371); if (lookahead == '/') ADVANCE(63); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1168); + lookahead == 'e') ADVANCE(1338); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(841); + lookahead == 'n') ADVANCE(953); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(878); + lookahead == 'o') ADVANCE(1000); if (lookahead == 'S' || - lookahead == 's') ADVANCE(896); + lookahead == 's') ADVANCE(1026); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1104); + lookahead == 'u') ADVANCE(1259); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(898); + lookahead == 'w') ADVANCE(1025); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7624,25 +8321,25 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(52) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 53: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '-') ADVANCE(1201); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '-') ADVANCE(1371); if (lookahead == '/') ADVANCE(63); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1010); + lookahead == 'i') ADVANCE(1152); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(842); + lookahead == 'n') ADVANCE(954); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1140); + lookahead == 'o') ADVANCE(1308); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7651,25 +8348,25 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(53) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 54: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '-') ADVANCE(1201); - if (lookahead == '.') ADVANCE(1179); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '-') ADVANCE(1371); + if (lookahead == '.') ADVANCE(1349); if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '?') ADVANCE(1182); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '?') ADVANCE(1352); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(842); + lookahead == 'n') ADVANCE(954); if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || @@ -7678,14 +8375,14 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == '\n' || lookahead == '\r' || lookahead == ' ') ADVANCE(54); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 55: - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '/') ADVANCE(1185); - if (lookahead == '\\') ADVANCE(17); - if (lookahead == '{') ADVANCE(666); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '/') ADVANCE(1355); + if (lookahead == '\\') ADVANCE(15); + if (lookahead == '{') ADVANCE(758); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7693,14 +8390,14 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) ADVANCE(1186); - if (lookahead != 0) ADVANCE(1187); + lookahead == 65279) ADVANCE(1356); + if (lookahead != 0) ADVANCE(1357); END_STATE(); case 56: - if (lookahead == '&') ADVANCE(669); + if (lookahead == '&') ADVANCE(761); if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7709,14 +8406,14 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(56) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 57: - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '/') ADVANCE(1190); - if (lookahead == '\\') ADVANCE(18); - if (lookahead == '{') ADVANCE(667); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '/') ADVANCE(1360); + if (lookahead == '\\') ADVANCE(16); + if (lookahead == '{') ADVANCE(759); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7724,109 +8421,118 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) ADVANCE(1191); - if (lookahead != 0) ADVANCE(1192); + lookahead == 65279) ADVANCE(1361); + if (lookahead != 0) ADVANCE(1362); END_STATE(); case 58: - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(1062); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(984); - if (lookahead == '\t' || - lookahead == '\n' || - lookahead == '\f' || - lookahead == '\r' || - lookahead == ' ' || - lookahead == 8203 || - lookahead == 8288 || - lookahead == 65279) SKIP(58) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); - END_STATE(); - case 59: - if (lookahead == '(') ADVANCE(1193); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(919); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1012); - if (lookahead == '\f' || - lookahead == 8203 || - lookahead == 8288 || - lookahead == 65279) SKIP(59) - if (lookahead == '\t' || - lookahead == '\n' || - lookahead == '\r' || - lookahead == ' ') ADVANCE(59); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); - END_STATE(); - case 60: - if (lookahead == ')') ADVANCE(1194); - if (lookahead == ',') ADVANCE(1256); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '.') ADVANCE(1349); if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '\\') SKIP(16) - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') SKIP(12) + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(180); + lookahead == 'a') ADVANCE(204); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(602); + lookahead == 'b') ADVANCE(689); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(536); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(184); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(629); + lookahead == 'e') ADVANCE(502); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(360); + lookahead == 'f') ADVANCE(416); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(398); + lookahead == 'g') ADVANCE(341); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(416); + lookahead == 'i') ADVANCE(505); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(293); + lookahead == 'l') ADVANCE(180); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(156); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(263); + lookahead == 'n') ADVANCE(300); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(317); + lookahead == 'o') ADVANCE(364); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(517); + lookahead == 'p') ADVANCE(590); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(613); + lookahead == 'q') ADVANCE(706); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(295); + lookahead == 'r') ADVANCE(343); if (lookahead == 'S' || - lookahead == 's') ADVANCE(254); + lookahead == 's') ADVANCE(301); if (lookahead == 'T' || - lookahead == 't') ADVANCE(286); + lookahead == 't') ADVANCE(320); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(548); + lookahead == 'u') ADVANCE(637); if (lookahead == 'V' || - lookahead == 'v') ADVANCE(154); + lookahead == 'v') ADVANCE(172); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(338); + lookahead == 'w') ADVANCE(390); + if (lookahead == '\f' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(58) + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(58); + END_STATE(); + case 59: + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '/') ADVANCE(63); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(1200); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1115); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || lookahead == '\r' || lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(59) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); + END_STATE(); + case 60: + if (lookahead == '(') ADVANCE(1363); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1052); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1151); + if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(60) + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(60); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 61: - if (lookahead == ')') ADVANCE(1194); + if (lookahead == ')') ADVANCE(1364); if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(853); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1153); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1140); + lookahead == 'o') ADVANCE(1308); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7835,25 +8541,25 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(61) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 62: - if (lookahead == '*') ADVANCE(657); - if (lookahead == '.') ADVANCE(127); - if (lookahead == '/') ADVANCE(649); + if (lookahead == '*') ADVANCE(749); + if (lookahead == '.') ADVANCE(137); + if (lookahead == '/') ADVANCE(741); if (('-' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(89); + lookahead == '|') ADVANCE(95); END_STATE(); case 63: - if (lookahead == '*') ADVANCE(657); - if (lookahead == '/') ADVANCE(647); + if (lookahead == '*') ADVANCE(749); + if (lookahead == '/') ADVANCE(739); END_STATE(); case 64: - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead == '/') ADVANCE(66); - if (lookahead == '\\') ADVANCE(21); - if (lookahead == '{') ADVANCE(665); + if (lookahead == '\\') ADVANCE(23); + if (lookahead == '{') ADVANCE(757); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7865,22 +8571,22 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead != 0) ADVANCE(65); END_STATE(); case 65: - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead != 0) ADVANCE(65); END_STATE(); case 66: - if (lookahead == '*') ADVANCE(658); - if (lookahead == '/') ADVANCE(648); + if (lookahead == '*') ADVANCE(750); + if (lookahead == '/') ADVANCE(740); if (lookahead != 0) ADVANCE(65); END_STATE(); case 67: - if (lookahead == ',') ADVANCE(1256); + if (lookahead == ',') ADVANCE(1430); if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(984); + lookahead == 'o') ADVANCE(1115); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -7889,121 +8595,204 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == 8203 || lookahead == 8288 || lookahead == 65279) SKIP(67) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 68: - if (lookahead == '-') ADVANCE(106); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1156); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1238); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(68) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); case 69: - if (lookahead == '-') ADVANCE(139); + if (lookahead == '-') ADVANCE(115); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(85); END_STATE(); case 70: - if (lookahead == '-') ADVANCE(351); + if (lookahead == '-') ADVANCE(154); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(85); END_STATE(); case 71: - if (lookahead == '-') ADVANCE(276); + if (lookahead == '-') ADVANCE(418); END_STATE(); case 72: - if (lookahead == '-') ADVANCE(107); + if (lookahead == '-') ADVANCE(321); END_STATE(); case 73: - if (lookahead == '-') ADVANCE(176); + if (lookahead == '-') ADVANCE(321); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(85); END_STATE(); case 74: - if (lookahead == '-') ADVANCE(277); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(84); + if (lookahead == '-') ADVANCE(116); END_STATE(); case 75: - if (lookahead == '-') ADVANCE(495); + if (lookahead == '-') ADVANCE(185); END_STATE(); case 76: - if (lookahead == '-') ADVANCE(599); + if (lookahead == '-') ADVANCE(366); END_STATE(); case 77: - if (lookahead == '-') ADVANCE(407); + if (lookahead == '-') ADVANCE(566); END_STATE(); case 78: - if (lookahead == '-') ADVANCE(407); - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1234); + if (lookahead == '-') ADVANCE(701); END_STATE(); case 79: - if (lookahead == '-') ADVANCE(399); + if (lookahead == '-') ADVANCE(425); END_STATE(); case 80: - if (lookahead == '-') ADVANCE(366); + if (lookahead == '-') ADVANCE(466); END_STATE(); case 81: - if (lookahead == '-') ADVANCE(486); + if (lookahead == '-') ADVANCE(466); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1405); END_STATE(); case 82: - if (lookahead == '-') ADVANCE(353); + if (lookahead == '-') ADVANCE(460); END_STATE(); case 83: - if (lookahead == '-') ADVANCE(597); + if (lookahead == '-') ADVANCE(148); END_STATE(); case 84: - if (lookahead == '-') ADVANCE(559); + if (lookahead == '-') ADVANCE(602); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(334); END_STATE(); case 85: - if (lookahead == '-') ADVANCE(408); + if (lookahead == '-') ADVANCE(638); END_STATE(); case 86: - if (lookahead == '-') ADVANCE(350); + if (lookahead == '-') ADVANCE(406); END_STATE(); case 87: - if (lookahead == '.') ADVANCE(1179); + if (lookahead == '-') ADVANCE(552); + END_STATE(); + case 88: + if (lookahead == '-') ADVANCE(686); + END_STATE(); + case 89: + if (lookahead == '-') ADVANCE(468); + END_STATE(); + case 90: + if (lookahead == '-') ADVANCE(417); + END_STATE(); + case 91: + if (lookahead == '.') ADVANCE(1351); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') SKIP(20) + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(191); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(697); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(601); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(91) + END_STATE(); + case 92: + if (lookahead == '.') ADVANCE(1349); if (lookahead == '/') ADVANCE(63); - if (lookahead == 'N') ADVANCE(705); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == 'N') ADVANCE(800); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(87) + lookahead == 65279) SKIP(92) if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') ADVANCE(87); - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == ' ') ADVANCE(92); + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 88: - if (lookahead == '.') ADVANCE(1179); + case 93: + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(63); + if (lookahead == 'S') ADVANCE(111); + if (lookahead == '\\') SKIP(14) + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(188); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(531); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(720); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(424); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(220); + if (lookahead == '\f' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(93) + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(93); + END_STATE(); + case 94: + if (lookahead == '.') ADVANCE(1349); if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1087); + lookahead == 'a') ADVANCE(1242); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(919); + lookahead == 'f') ADVANCE(1052); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1012); + lookahead == 'i') ADVANCE(1151); if (lookahead == '\f' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(88) + lookahead == 65279) SKIP(94) if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') ADVANCE(88); - if (('B' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == ' ') ADVANCE(94); + if (('B' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 89: - if (lookahead == '.') ADVANCE(127); + case 95: + if (lookahead == '.') ADVANCE(137); if (('-' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(89); + lookahead == '|') ADVANCE(95); END_STATE(); - case 90: + case 96: if (lookahead == '/') ADVANCE(63); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(984); + lookahead == 'o') ADVANCE(1115); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1289); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1210); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(893); + lookahead == 'w') ADVANCE(1019); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8011,31 +8800,52 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(90) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(96) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 91: + case 97: + if (lookahead == '/') ADVANCE(63); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1115); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1289); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1210); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(97) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); + END_STATE(); + case 98: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(718); + lookahead == 'c') ADVANCE(817); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); + lookahead == 'd') ADVANCE(947); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(943); + lookahead == 'e') ADVANCE(1074); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(915); + lookahead == 'f') ADVANCE(1049); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1124); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(983); + lookahead == 'o') ADVANCE(1114); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1074); + lookahead == 'p') ADVANCE(1225); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(834); + lookahead == 'r') ADVANCE(949); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1003); + lookahead == 'u') ADVANCE(1142); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8043,31 +8853,31 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(91) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(98) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 92: + case 99: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(718); + lookahead == 'c') ADVANCE(817); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); + lookahead == 'd') ADVANCE(947); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(982); + lookahead == 'e') ADVANCE(1113); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(915); + lookahead == 'f') ADVANCE(1049); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); + lookahead == 'i') ADVANCE(1124); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(983); + lookahead == 'o') ADVANCE(1114); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1074); + lookahead == 'p') ADVANCE(1225); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(834); + lookahead == 'r') ADVANCE(949); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1003); + lookahead == 'u') ADVANCE(1142); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8075,15 +8885,15 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(92) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(99) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 93: + case 100: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(955); + lookahead == 'c') ADVANCE(1089); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8091,19 +8901,17 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(93) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(100) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 94: + case 101: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(918); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(992); + lookahead == 'f') ADVANCE(1051); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8111,17 +8919,19 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(94) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(101) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 95: + case 102: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); + lookahead == 'd') ADVANCE(1156); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(918); + lookahead == 'f') ADVANCE(1159); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(949); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8129,19 +8939,15 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(95) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(102) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 96: + case 103: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1021); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(834); + lookahead == 'd') ADVANCE(853); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8149,19 +8955,19 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(96) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(103) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 97: + case 104: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(917); + lookahead == 'f') ADVANCE(1042); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(749); + lookahead == 'l') ADVANCE(848); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(848); + lookahead == 'n') ADVANCE(959); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8169,17 +8975,17 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(97) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(104) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 98: + case 105: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(917); + lookahead == 'f') ADVANCE(1042); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(749); + lookahead == 'l') ADVANCE(848); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8187,15 +8993,15 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(98) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(105) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 99: + case 106: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1082); + lookahead == 'f') ADVANCE(1238); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8203,15 +9009,33 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(99) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(106) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 100: + case 107: + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(1211); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(1157); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(107) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); + END_STATE(); + case 108: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); if (lookahead == 'T' || - lookahead == 't') ADVANCE(810); + lookahead == 't') ADVANCE(982); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8219,15 +9043,15 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(100) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(108) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 101: + case 109: if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(893); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(1157); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8235,13 +9059,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(101) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(109) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 102: + case 110: if (lookahead == '/') ADVANCE(62); - if (lookahead == '\\') ADVANCE(24); - if (lookahead == '{') ADVANCE(664); + if (lookahead == '\\') ADVANCE(22); + if (lookahead == '{') ADVANCE(756); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -8249,2516 +9073,2891 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(102) + lookahead == 65279) SKIP(110) if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= '|')) ADVANCE(89); + ('A' <= lookahead && lookahead <= '|')) ADVANCE(95); END_STATE(); - case 103: - if (lookahead == 'C') ADVANCE(121); + case 111: + if (lookahead == 'C') ADVANCE(130); + END_STATE(); + case 112: + if (lookahead == 'C') ADVANCE(130); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(519); + lookahead == 'e') ADVANCE(586); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(144); + lookahead == 'h') ADVANCE(161); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(373); if (lookahead == 'T' || - lookahead == 't') ADVANCE(472); + lookahead == 't') ADVANCE(539); END_STATE(); - case 104: - if (lookahead == 'C') ADVANCE(121); + case 113: + if (lookahead == 'C') ADVANCE(130); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(586); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(144); + lookahead == 'h') ADVANCE(161); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(538); END_STATE(); - case 105: - if (lookahead == 'E') ADVANCE(1245); - if (lookahead == 'e') ADVANCE(1245); + case 114: + if (lookahead == 'E') ADVANCE(1419); + if (lookahead == 'e') ADVANCE(1419); END_STATE(); - case 106: - if (lookahead == 'E') ADVANCE(125); - if (lookahead == 'e') ADVANCE(538); + case 115: + if (lookahead == 'E') ADVANCE(134); + if (lookahead == 'e') ADVANCE(615); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(500); + lookahead == 'a') ADVANCE(569); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(476); + lookahead == 'l') ADVANCE(537); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(449); + lookahead == 'u') ADVANCE(513); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(161); + lookahead == 'w') ADVANCE(158); END_STATE(); - case 107: - if (lookahead == 'E') ADVANCE(126); + case 116: + if (lookahead == 'E') ADVANCE(135); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(449); - END_STATE(); - case 108: - if (lookahead == 'G') ADVANCE(1250); + lookahead == 'u') ADVANCE(513); END_STATE(); - case 109: - if (lookahead == 'I') ADVANCE(114); + case 117: + if (lookahead == 'G') ADVANCE(1424); END_STATE(); - case 110: - if (lookahead == 'I') ADVANCE(111); - if (lookahead == 'i') ADVANCE(375); + case 118: + if (lookahead == 'I') ADVANCE(120); + if (lookahead == 'i') ADVANCE(434); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(181); + lookahead == 'a') ADVANCE(206); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); + lookahead == 'e') ADVANCE(1386); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); - END_STATE(); - case 111: - if (lookahead == 'K') ADVANCE(105); - if (lookahead == 'k') ADVANCE(230); - END_STATE(); - case 112: - if (lookahead == 'L') ADVANCE(109); - END_STATE(); - case 113: - if (lookahead == 'L') ADVANCE(112); - END_STATE(); - case 114: - if (lookahead == 'N') ADVANCE(108); - END_STATE(); - case 115: - if (lookahead == 'O') ADVANCE(68); - if (lookahead == 'o') ADVANCE(69); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); - END_STATE(); - case 116: - if (lookahead == 'O') ADVANCE(113); - END_STATE(); - case 117: - if (lookahead == 'O') ADVANCE(123); - END_STATE(); - case 118: - if (lookahead == 'O') ADVANCE(120); - if (lookahead == 'o') ADVANCE(509); + lookahead == 't') ADVANCE(1385); END_STATE(); case 119: - if (lookahead == 'O') ADVANCE(72); - if (lookahead == 'o') ADVANCE(76); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); + if (lookahead == 'I') ADVANCE(123); END_STATE(); case 120: - if (lookahead == 'R') ADVANCE(1306); - if (lookahead == 'r') ADVANCE(1306); + if (lookahead == 'K') ADVANCE(114); + if (lookahead == 'k') ADVANCE(265); END_STATE(); case 121: - if (lookahead == 'R') ADVANCE(116); + if (lookahead == 'L') ADVANCE(119); END_STATE(); case 122: - if (lookahead == 'R') ADVANCE(118); - if (lookahead == 'r') ADVANCE(483); + if (lookahead == 'L') ADVANCE(121); END_STATE(); case 123: - if (lookahead == 'R') ADVANCE(1279); + if (lookahead == 'N') ADVANCE(117); END_STATE(); case 124: - if (lookahead == 'R') ADVANCE(117); + if (lookahead == 'O') ADVANCE(69); + if (lookahead == 'o') ADVANCE(70); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1387); END_STATE(); case 125: - if (lookahead == 'R') ADVANCE(122); - if (lookahead == 'r') ADVANCE(534); + if (lookahead == 'O') ADVANCE(122); END_STATE(); case 126: - if (lookahead == 'R') ADVANCE(124); + if (lookahead == 'O') ADVANCE(132); END_STATE(); case 127: - if (lookahead == 'i') ADVANCE(646); + if (lookahead == 'O') ADVANCE(129); + if (lookahead == 'o') ADVANCE(579); END_STATE(); case 128: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(207); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(138); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(384); + if (lookahead == 'O') ADVANCE(74); + if (lookahead == 'o') ADVANCE(78); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1387); END_STATE(); case 129: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(182); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(375); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + if (lookahead == 'R') ADVANCE(1497); + if (lookahead == 'r') ADVANCE(1497); END_STATE(); case 130: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(577); + if (lookahead == 'R') ADVANCE(125); END_STATE(); case 131: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(187); + if (lookahead == 'R') ADVANCE(127); + if (lookahead == 'r') ADVANCE(551); END_STATE(); case 132: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(578); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(464); + if (lookahead == 'R') ADVANCE(1465); END_STATE(); case 133: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(196); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(550); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(212); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(515); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(195); + if (lookahead == 'R') ADVANCE(126); END_STATE(); case 134: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(371); + if (lookahead == 'R') ADVANCE(131); + if (lookahead == 'r') ADVANCE(610); END_STATE(); case 135: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(422); + if (lookahead == 'R') ADVANCE(133); END_STATE(); case 136: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(422); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(410); + if (lookahead == 'Y') ADVANCE(1488); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(374); END_STATE(); case 137: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(185); + if (lookahead == 'i') ADVANCE(738); END_STATE(); case 138: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(552); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(555); + lookahead == 'a') ADVANCE(206); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1386); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(434); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1385); END_STATE(); case 139: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(500); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(538); + lookahead == 'a') ADVANCE(235); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(476); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(449); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(161); + lookahead == 'l') ADVANCE(150); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(440); END_STATE(); case 140: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(383); + lookahead == 'a') ADVANCE(660); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(226); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1438); END_STATE(); case 141: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(520); + lookahead == 'a') ADVANCE(221); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(630); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(241); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(1389); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(340); + lookahead == 'r') ADVANCE(589); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(309); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(217); END_STATE(); case 142: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(630); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(465); + lookahead == 'a') ADVANCE(84); END_STATE(); case 143: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(393); + lookahead == 'a') ADVANCE(211); END_STATE(); case 144: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(524); + lookahead == 'a') ADVANCE(430); END_STATE(); case 145: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(203); + lookahead == 'a') ADVANCE(678); END_STATE(); case 146: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(418); + lookahead == 'a') ADVANCE(678); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(659); END_STATE(); case 147: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(395); + lookahead == 'a') ADVANCE(481); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(471); END_STATE(); case 148: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(378); + lookahead == 'a') ADVANCE(371); END_STATE(); case 149: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(572); + lookahead == 'a') ADVANCE(209); END_STATE(); case 150: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(514); + lookahead == 'a') ADVANCE(628); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(633); END_STATE(); case 151: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(587); + lookahead == 'a') ADVANCE(229); END_STATE(); case 152: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(417); + lookahead == 'a') ADVANCE(592); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(392); END_STATE(); case 153: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(401); + lookahead == 'a') ADVANCE(230); END_STATE(); case 154: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(513); + lookahead == 'a') ADVANCE(569); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(615); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(537); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(513); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(158); END_STATE(); case 155: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(382); + lookahead == 'a') ADVANCE(442); END_STATE(); case 156: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(379); + lookahead == 'a') ADVANCE(719); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(659); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(528); END_STATE(); case 157: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(582); + lookahead == 'a') ADVANCE(510); END_STATE(); case 158: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(377); + lookahead == 'a') ADVANCE(408); END_STATE(); case 159: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(567); + lookahead == 'a') ADVANCE(453); END_STATE(); case 160: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(594); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(294); + lookahead == 'a') ADVANCE(479); END_STATE(); case 161: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(356); + lookahead == 'a') ADVANCE(595); END_STATE(); case 162: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(423); + lookahead == 'a') ADVANCE(454); END_STATE(); case 163: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(181); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(375); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + lookahead == 'a') ADVANCE(662); END_STATE(); case 164: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(181); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + lookahead == 'a') ADVANCE(443); END_STATE(); case 165: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(325); + lookahead == 'a') ADVANCE(478); END_STATE(); case 166: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(450); + lookahead == 'a') ADVANCE(676); END_STATE(); case 167: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(618); + lookahead == 'a') ADVANCE(653); END_STATE(); case 168: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(326); + lookahead == 'a') ADVANCE(585); END_STATE(); case 169: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(557); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(447); + lookahead == 'a') ADVANCE(671); END_STATE(); case 170: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(533); + lookahead == 'a') ADVANCE(459); END_STATE(); case 171: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(188); + lookahead == 'a') ADVANCE(444); END_STATE(); case 172: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(206); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(384); + lookahead == 'a') ADVANCE(584); END_STATE(); case 173: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(362); + lookahead == 'a') ADVANCE(436); END_STATE(); case 174: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(189); + lookahead == 'a') ADVANCE(437); END_STATE(); case 175: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(190); + lookahead == 'a') ADVANCE(669); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(342); END_STATE(); case 176: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(621); - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(479); - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(142); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(490); + lookahead == 'a') ADVANCE(648); END_STATE(); case 177: if (lookahead == 'A' || - lookahead == 'a') ADVANCE(409); + lookahead == 'a') ADVANCE(708); END_STATE(); case 178: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(551); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(636); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1244); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(483); END_STATE(); case 179: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(551); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(216); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1244); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(205); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1386); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1385); END_STATE(); case 180: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(551); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(211); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(205); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(177); END_STATE(); case 181: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(273); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(238); END_STATE(); case 182: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(273); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(560); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(405); END_STATE(); case 183: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(73); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(376); END_STATE(); case 184: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(158); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(670); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(226); END_STATE(); case 185: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(284); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(710); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(547); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(198); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(560); END_STATE(); case 186: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(396); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(377); END_STATE(); case 187: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(402); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(516); END_STATE(); case 188: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(404); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(234); END_STATE(); case 189: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(405); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(234); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(440); END_STATE(); case 190: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(406); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(634); END_STATE(); case 191: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1235); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(636); END_STATE(); case 192: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1238); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(607); END_STATE(); case 193: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(471); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(212); END_STATE(); case 194: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(471); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(576); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(213); END_STATE(); case 195: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(272); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(684); END_STATE(); case 196: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(327); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(214); END_STATE(); case 197: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(372); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(685); END_STATE(); case 198: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(328); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(721); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(529); END_STATE(); case 199: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(373); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(470); END_STATE(); case 200: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(374); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(629); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(728); END_STATE(); case 201: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(345); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(629); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(728); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1418); END_STATE(); case 202: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(389); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(629); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(247); END_STATE(); case 203: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(569); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(629); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(247); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1418); END_STATE(); case 204: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(283); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(629); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(240); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(350); END_STATE(); case 205: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(282); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(310); END_STATE(); case 206: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(334); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(310); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(640); END_STATE(); case 207: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(334); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(198); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(75); END_STATE(); case 208: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(593); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(173); END_STATE(); case 209: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(337); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(330); END_STATE(); case 210: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(589); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(457); END_STATE(); case 211: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1315); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(461); END_STATE(); case 212: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1180); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(463); END_STATE(); case 213: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1331); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(464); END_STATE(); case 214: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1237); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(465); END_STATE(); case 215: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(3); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(1406); END_STATE(); case 216: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(3); - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(625); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(1409); END_STATE(); case 217: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(324); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(314); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(346); END_STATE(); case 218: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(467); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(505); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(540); END_STATE(); case 219: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(80); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(540); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(369); END_STATE(); case 220: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(469); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(540); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(571); END_STATE(); case 221: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(549); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(378); END_STATE(); case 222: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(306); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(431); END_STATE(); case 223: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(262); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(432); END_STATE(); case 224: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(267); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(379); END_STATE(); case 225: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(271); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(590); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(412); END_STATE(); case 226: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(615); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(412); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1413); END_STATE(); case 227: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(403); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(433); END_STATE(); case 228: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(449); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + lookahead == 't') ADVANCE(346); END_STATE(); case 229: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1221); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1220); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(651); END_STATE(); case 230: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1245); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(287); END_STATE(); case 231: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1298); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(323); END_STATE(); case 232: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1260); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(313); END_STATE(); case 233: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1249); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(332); END_STATE(); case 234: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1286); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(382); END_STATE(); case 235: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1205); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(382); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(224); END_STATE(); case 236: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1301); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(674); END_STATE(); case 237: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1262); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(384); END_STATE(); case 238: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1333); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(682); END_STATE(); case 239: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1318); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(687); END_STATE(); case 240: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1236); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1506); END_STATE(); case 241: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1340); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1350); END_STATE(); case 242: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1241); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1445); END_STATE(); case 243: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1300); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1396); END_STATE(); case 244: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1266); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1521); END_STATE(); case 245: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1248); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1456); END_STATE(); case 246: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1323); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1408); END_STATE(); case 247: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1239); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(3); + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(715); END_STATE(); case 248: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1285); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(532); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(575); END_STATE(); case 249: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(375); END_STATE(); case 250: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(69); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(79); END_STATE(); case 251: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(71); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(535); END_STATE(); case 252: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(76); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(298); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(344); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(675); END_STATE(); case 253: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(519); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(298); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(144); + lookahead == 'h') ADVANCE(344); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(675); if (lookahead == 'T' || - lookahead == 't') ADVANCE(472); + lookahead == 't') ADVANCE(324); END_STATE(); case 254: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(519); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(170); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(160); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(298); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(675); END_STATE(); case 255: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(323); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(298); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(675); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(698); END_STATE(); case 256: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(323); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(268); - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1309); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(623); END_STATE(); case 257: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(201); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(317); END_STATE(); case 258: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(201); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1264); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(627); END_STATE(); case 259: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(391); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(140); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(553); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(278); END_STATE(); case 260: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(432); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(307); END_STATE(); case 261: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(433); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(400); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(311); END_STATE(); case 262: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(626); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(462); END_STATE(); case 263: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(622); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(74); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(705); END_STATE(); case 264: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1291); + lookahead == 'e') ADVANCE(1391); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1390); END_STATE(); case 265: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(78); + lookahead == 'e') ADVANCE(1419); END_STATE(); case 266: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1240); + lookahead == 'e') ADVANCE(1489); END_STATE(); case 267: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(627); + lookahead == 'e') ADVANCE(1434); END_STATE(); case 268: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(134); + lookahead == 'e') ADVANCE(1423); END_STATE(); case 269: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(70); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(444); + lookahead == 'e') ADVANCE(1472); END_STATE(); case 270: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(321); + lookahead == 'e') ADVANCE(1375); END_STATE(); case 271: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(628); + lookahead == 'e') ADVANCE(1492); END_STATE(); case 272: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(497); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(603); + lookahead == 'e') ADVANCE(1436); END_STATE(); case 273: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(376); + lookahead == 'e') ADVANCE(1412); END_STATE(); case 274: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(77); + lookahead == 'e') ADVANCE(1523); END_STATE(); case 275: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(499); + lookahead == 'e') ADVANCE(1509); END_STATE(); case 276: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(538); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(476); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(449); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(161); + lookahead == 'e') ADVANCE(1407); END_STATE(); case 277: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(538); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(476); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(161); + lookahead == 'e') ADVANCE(1526); END_STATE(); case 278: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(146); + lookahead == 'e') ADVANCE(1449); END_STATE(); case 279: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(543); + lookahead == 'e') ADVANCE(1415); END_STATE(); case 280: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(455); + lookahead == 'e') ADVANCE(1455); END_STATE(); case 281: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(516); + lookahead == 'e') ADVANCE(1491); END_STATE(); case 282: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(226); + lookahead == 'e') ADVANCE(1439); END_STATE(); case 283: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(81); + lookahead == 'e') ADVANCE(1422); END_STATE(); case 284: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(380); + lookahead == 'e') ADVANCE(1514); END_STATE(); case 285: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(214); + lookahead == 'e') ADVANCE(1410); END_STATE(); case 286: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(420); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(527); + lookahead == 'e') ADVANCE(1471); END_STATE(); case 287: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(510); + lookahead == 'e') ADVANCE(1447); END_STATE(); case 288: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(592); + lookahead == 'e') ADVANCE(1387); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(70); END_STATE(); case 289: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(521); + lookahead == 'e') ADVANCE(1387); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(72); END_STATE(); case 290: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(579); + lookahead == 'e') ADVANCE(1387); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(78); END_STATE(); case 291: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(453); + lookahead == 'e') ADVANCE(586); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(161); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(373); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(539); END_STATE(); case 292: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(508); + lookahead == 'e') ADVANCE(586); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(161); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(538); END_STATE(); case 293: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(167); + lookahead == 'e') ADVANCE(452); END_STATE(); case 294: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(152); + lookahead == 'e') ADVANCE(452); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(155); END_STATE(); case 295: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(575); + lookahead == 'e') ADVANCE(452); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(155); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(631); END_STATE(); case 296: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(535); + lookahead == 'e') ADVANCE(452); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(170); END_STATE(); case 297: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(394); + lookahead == 'e') ADVANCE(494); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(458); END_STATE(); case 298: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(529); + lookahead == 'e') ADVANCE(718); END_STATE(); case 299: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(424); + lookahead == 'e') ADVANCE(1411); END_STATE(); case 300: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(528); + lookahead == 'e') ADVANCE(712); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(73); END_STATE(); case 301: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(526); + lookahead == 'e') ADVANCE(587); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(192); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(175); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(207); END_STATE(); case 302: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(210); + lookahead == 'e') ADVANCE(1478); END_STATE(); case 303: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(458); + lookahead == 'e') ADVANCE(81); END_STATE(); case 304: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(531); + lookahead == 'e') ADVANCE(374); END_STATE(); case 305: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(159); + lookahead == 'e') ADVANCE(374); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(506); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(308); + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1500); END_STATE(); case 306: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(82); + lookahead == 'e') ADVANCE(71); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(508); END_STATE(); case 307: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(539); + lookahead == 'e') ADVANCE(716); END_STATE(); case 308: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(86); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(444); + lookahead == 'e') ADVANCE(144); END_STATE(); case 309: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(85); + lookahead == 'e') ADVANCE(512); END_STATE(); case 310: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(540); + lookahead == 'e') ADVANCE(435); END_STATE(); case 311: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(717); END_STATE(); case 312: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(493); END_STATE(); case 313: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(567); END_STATE(); case 314: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(333); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(567); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(690); END_STATE(); case 315: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(333); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(80); END_STATE(); case 316: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(225); END_STATE(); case 317: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(580); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(86); END_STATE(); case 318: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(320); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(491); END_STATE(); case 319: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(492); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(612); END_STATE(); case 320: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(292); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(486); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(598); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(672); END_STATE(); case 321: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(304); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(615); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(537); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(513); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(158); END_STATE(); case 322: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(1314); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(620); END_STATE(); case 323: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(344); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(87); END_STATE(); case 324: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(290); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(583); END_STATE(); case 325: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(239); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(160); END_STATE(); case 326: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(246); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(588); END_STATE(); case 327: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(1310); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(469); END_STATE(); case 328: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(1316); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(613); END_STATE(); case 329: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(144); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(523); END_STATE(); case 330: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(260); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1265); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(438); END_STATE(); case 331: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(261); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(518); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(246); END_STATE(); case 332: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(296); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(610); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(263); END_STATE(); case 333: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(281); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(600); END_STATE(); case 334: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(233); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(650); END_STATE(); case 335: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(166); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(580); END_STATE(); case 336: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(298); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(581); END_STATE(); case 337: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(279); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(679); END_STATE(); case 338: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(301); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(593); END_STATE(); case 339: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(259); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(512); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(136); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(578); END_STATE(); case 340: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(426); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(664); END_STATE(); case 341: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(638); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(655); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(542); END_STATE(); case 342: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(620); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(165); END_STATE(); case 343: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(619); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(588); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(658); END_STATE(); case 344: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(448); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(611); END_STATE(); case 345: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(421); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(455); END_STATE(); case 346: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(217); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(517); END_STATE(); case 347: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(143); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(467); END_STATE(); case 348: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(561); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(520); END_STATE(); case 349: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(427); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(236); END_STATE(); case 350: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(460); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(605); END_STATE(); case 351: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(460); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(346); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(604); END_STATE(); case 352: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(482); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(599); END_STATE(); case 353: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(441); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(176); END_STATE(); case 354: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(148); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(616); END_STATE(); case 355: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(192); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(89); END_STATE(); case 356: + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(90); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(568); + lookahead == 'i') ADVANCE(508); END_STATE(); case 357: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(191); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(617); END_STATE(); case 358: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(583); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); END_STATE(); case 359: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(454); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(512); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(135); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1475); END_STATE(); case 360: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(446); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1475); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1); END_STATE(); case 361: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(297); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(512); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1475); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(388); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(319); END_STATE(); case 362: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(452); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1475); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(388); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(319); END_STATE(); case 363: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(556); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1); END_STATE(); case 364: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(487); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1504); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(663); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(319); END_STATE(); case 365: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(428); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(370); END_STATE(); case 366: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(463); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(411); END_STATE(); case 367: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(430); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(153); END_STATE(); case 368: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(431); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(561); END_STATE(); case 369: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(639); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(328); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(163); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(694); END_STATE(); case 370: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(177); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(339); END_STATE(); case 371: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1308); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(680); END_STATE(); case 372: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1302); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(1505); END_STATE(); case 373: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1303); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(525); END_STATE(); case 374: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1304); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(399); END_STATE(); case 375: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(230); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(340); END_STATE(); case 376: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1228); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(275); END_STATE(); case 377: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1233); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(284); END_STATE(); case 378: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1226); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(1501); END_STATE(); case 379: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1327); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(1507); END_STATE(); case 380: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1229); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(161); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(543); END_STATE(); case 381: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1275); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(297); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(591); END_STATE(); case 382: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1322); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(268); END_STATE(); case 383: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1277); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(187); END_STATE(); case 384: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(601); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(581); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(322); END_STATE(); case 385: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(601); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(581); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(457); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(544); END_STATE(); case 386: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(550); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(312); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1474); END_STATE(); case 387: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(550); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(202); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(312); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1474); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(157); END_STATE(); case 388: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(637); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(326); END_STATE(); case 389: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(603); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(351); END_STATE(); case 390: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(633); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(352); END_STATE(); case 391: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(221); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(295); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(582); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(147); END_STATE(); case 392: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(635); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(484); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(573); END_STATE(); case 393: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(341); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(730); END_STATE(); case 394: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(213); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(711); END_STATE(); case 395: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(545); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(294); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(582); END_STATE(); case 396: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(355); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(709); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(574); END_STATE(); case 397: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(299); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(243); END_STATE(); case 398: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(475); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(548); END_STATE(); case 399: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(137); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(511); END_STATE(); case 400: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(237); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(216); END_STATE(); case 401: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(390); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(215); END_STATE(); case 402: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(247); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(485); END_STATE(); case 403: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(248); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(159); END_STATE(); case 404: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(242); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(249); END_STATE(); case 405: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(245); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(515); END_STATE(); case 406: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(266); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(509); END_STATE(); case 407: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(477); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(164); END_STATE(); case 408: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(481); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(649); END_STATE(); case 409: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(369); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(667); END_STATE(); case 410: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1287); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(641); END_STATE(); case 411: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1320); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(345); END_STATE(); case 412: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1321); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(482); END_STATE(); case 413: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1325); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(296); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(582); END_STATE(); case 414: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1326); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(259); END_STATE(); case 415: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(494); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1337); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(550); END_STATE(); case 416: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(494); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(332); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(293); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(582); END_STATE(); case 417: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1282); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(526); END_STATE(); case 418: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1283); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(526); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(404); END_STATE(); case 419: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(461); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(635); END_STATE(); case 420: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(498); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(553); END_STATE(); case 421: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(147); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(554); END_STATE(); case 422: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(235); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(555); END_STATE(); case 423: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(288); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(487); END_STATE(); case 424: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(280); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(347); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(576); END_STATE(); case 425: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(149); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(527); END_STATE(); case 426: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(150); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(151); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(489); END_STATE(); case 427: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(604); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(490); END_STATE(); case 428: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(605); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(731); END_STATE(); case 429: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(157); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(199); END_STATE(); case 430: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(607); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(1499); END_STATE(); case 431: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(608); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(1493); END_STATE(); case 432: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1259); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(1494); END_STATE(); case 433: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1299); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(236); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(1495); END_STATE(); case 434: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1268); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(265); END_STATE(); case 435: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1270); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1399); END_STATE(); case 436: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1252); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1404); END_STATE(); case 437: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1267); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1518); END_STATE(); case 438: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(636); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1400); END_STATE(); case 439: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(218); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(269); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1462); END_STATE(); case 440: + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(688); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(216); + lookahead == 'n') ADVANCE(666); END_STATE(); case 441: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(319); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(688); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(521); END_STATE(); case 442: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1339); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1463); END_STATE(); case 443: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1336); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1397); END_STATE(); case 444: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(322); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1513); END_STATE(); case 445: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(225); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(630); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(1389); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(589); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(228); END_STATE(); case 446: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(140); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(630); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(1389); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(228); END_STATE(); case 447: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(581); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(630); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(1389); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(681); END_STATE(); case 448: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(542); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(729); END_STATE(); case 449: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(220); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(690); END_STATE(); case 450: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(227); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(727); END_STATE(); case 451: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(215); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(300); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(724); END_STATE(); case 452: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(544); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(244); END_STATE(); case 453: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(204); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(393); END_STATE(); case 454: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(153); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(625); END_STATE(); case 455: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(584); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(256); END_STATE(); case 456: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(392); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(318); END_STATE(); case 457: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(562); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(400); END_STATE(); case 458: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(565); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(272); END_STATE(); case 459: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(570); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(451); END_STATE(); case 460: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(223); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(149); END_STATE(); case 461: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(79); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(285); END_STATE(); case 462: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(208); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(286); END_STATE(); case 463: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(224); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(299); END_STATE(); case 464: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(365); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(279); END_STATE(); case 465: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(368); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(283); END_STATE(); case 466: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1264); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(556); END_STATE(); case 467: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1290); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(258); END_STATE(); case 468: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(384); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(557); END_STATE(); case 469: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1231); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(195); END_STATE(); case 470: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(385); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(428); END_STATE(); case 471: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(222); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1473); END_STATE(); case 472: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(493); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(278); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1511); END_STATE(); case 473: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(512); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(135); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1512); END_STATE(); case 474: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(623); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1516); END_STATE(); case 475: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(184); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1517); END_STATE(); case 476: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(197); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(563); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(253); END_STATE(); case 477: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(199); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(563); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(252); END_STATE(); case 478: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(484); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1468); END_STATE(); case 479: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(614); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(1470); END_STATE(); case 480: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(507); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(524); END_STATE(); case 481: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(200); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(270); END_STATE(); case 482: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(436); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(162); END_STATE(); case 483: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(509); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(337); END_STATE(); case 484: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(381); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(168); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(169); END_STATE(); case 485: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(506); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(135); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(462); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(691); END_STATE(); case 486: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(456); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(568); END_STATE(); case 487: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(435); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(692); END_STATE(); case 488: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(585); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(167); END_STATE(); case 489: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(205); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(693); END_STATE(); case 490: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(586); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(695); END_STATE(); case 491: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(616); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(348); END_STATE(); case 492: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(537); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(197); END_STATE(); case 493: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1296); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1433); END_STATE(); case 494: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(397); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1490); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(271); END_STATE(); case 495: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(478); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1441); END_STATE(); case 496: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(388); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1443); END_STATE(); case 497: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(564); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1487); END_STATE(); case 498: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(83); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1457); END_STATE(); case 499: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(305); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1426); END_STATE(); case 500: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(496); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1440); END_STATE(); case 501: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(611); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(728); END_STATE(); case 502: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(612); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(241); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(309); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(228); END_STATE(); case 503: - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(248); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(306); END_STATE(); case 504: - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(595); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(247); END_STATE(); case 505: - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(609); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(255); END_STATE(); case 506: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1247); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(242); END_STATE(); case 507: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1289); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(254); END_STATE(); case 508: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1246); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(372); END_STATE(); case 509: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1306); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(368); END_STATE(); case 510: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1269); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(639); END_STATE(); case 511: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(619); END_STATE(); case 512: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(425); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(643); END_STATE(); case 513: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1243); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(251); END_STATE(); case 514: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(634); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(76); END_STATE(); case 515: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(480); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(621); END_STATE(); case 516: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(624); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(262); END_STATE(); case 517: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(343); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(186); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(646); END_STATE(); case 518: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(219); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(450); END_STATE(); case 519: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(347); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(273); END_STATE(); case 520: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(162); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(668); END_STATE(); case 521: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(631); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(642); END_STATE(); case 522: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(434); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(652); END_STATE(); case 523: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(632); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(530); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(231); END_STATE(); case 524: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(274); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(82); END_STATE(); case 525: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(145); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(166); END_STATE(); case 526: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(236); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(260); END_STATE(); case 527: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(474); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(261); END_STATE(); case 528: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(165); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(423); END_STATE(); case 529: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(241); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(427); END_STATE(); case 530: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(437); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(239); END_STATE(); case 531: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(291); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1438); END_STATE(); case 532: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(244); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1477); END_STATE(); case 533: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(265); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(440); END_STATE(); case 534: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(483); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(397); END_STATE(); case 535: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(358); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1402); END_STATE(); case 536: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(489); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(441); END_STATE(); case 537: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(429); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(222); END_STATE(); case 538: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(534); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(564); END_STATE(); case 539: + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(564); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(168); + lookahead == 'r') ADVANCE(325); END_STATE(); case 540: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(370); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(257); END_STATE(); case 541: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1272); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(713); END_STATE(); case 542: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1222); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(208); END_STATE(); case 543: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1223); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(562); END_STATE(); case 544: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1224); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(245); END_STATE(); case 545: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1230); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(549); END_STATE(); case 546: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1273); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(577); END_STATE(); case 547: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1274); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(704); END_STATE(); case 548: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(269); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(514); END_STATE(); case 549: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1254); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(439); END_STATE(); case 550: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(232); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(497); END_STATE(); case 551: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(591); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(579); END_STATE(); case 552: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(541); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(518); END_STATE(); case 553: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(563); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(498); END_STATE(); case 554: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(342); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(499); END_STATE(); case 555: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(234); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(496); END_STATE(); case 556: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(243); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(223); END_STATE(); case 557: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(231); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(227); END_STATE(); case 558: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(308); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(707); END_STATE(); case 559: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(310); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(233); END_STATE(); case 560: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1312); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(673); END_STATE(); case 561: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1297); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(614); END_STATE(); case 562: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1319); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(1483); END_STATE(); case 563: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1311); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(456); END_STATE(); case 564: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1255); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(83); END_STATE(); case 565: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1330); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(448); END_STATE(); case 566: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1257); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(545); END_STATE(); case 567: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1263); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(645); END_STATE(); case 568: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1305); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(88); END_STATE(); case 569: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1276); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(565); END_STATE(); case 570: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1324); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(699); END_STATE(); case 571: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1258); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(353); END_STATE(); case 572: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1227); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(700); END_STATE(); case 573: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1292); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(333); END_STATE(); case 574: + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(333); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1204); + lookahead == 't') ADVANCE(349); END_STATE(); case 575: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(523); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(696); END_STATE(); case 576: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(606); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1421); END_STATE(); case 577: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(209); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1476); END_STATE(); case 578: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(209); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(349); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1420); END_STATE(); case 579: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(75); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1497); END_STATE(); case 580: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(501); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1442); END_STATE(); case 581: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(173); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1486); END_STATE(); case 582: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(352); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(488); END_STATE(); case 583: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(546); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(367); END_STATE(); case 584: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(547); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1417); END_STATE(); case 585: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(155); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(725); END_STATE(); case 586: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(156); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(403); END_STATE(); case 587: + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(403); if (lookahead == 'T' || - lookahead == 't') ADVANCE(240); + lookahead == 't') ADVANCE(1451); END_STATE(); case 588: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(302); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(714); END_STATE(); case 589: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(285); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(546); END_STATE(); case 590: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(354); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(396); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(210); END_STATE(); case 591: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(525); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(250); END_STATE(); case 592: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(287); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(178); END_STATE(); case 593: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(364); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(722); END_STATE(); case 594: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(357); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(723); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(603); END_STATE(); case 595: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(303); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(315); END_STATE(); case 596: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(502); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(495); END_STATE(); case 597: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(174); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(151); END_STATE(); case 598: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(348); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(541); END_STATE(); case 599: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(449); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(271); END_STATE(); case 600: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(183); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(661); END_STATE(); case 601: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(419); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(559); END_STATE(); case 602: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(318); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(327); END_STATE(); case 603: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(554); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(500); END_STATE(); case 604: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(411); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(277); END_STATE(); case 605: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(412); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(183); END_STATE(); case 606: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(522); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(280); END_STATE(); case 607: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(413); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(303); END_STATE(); case 608: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(414); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(282); END_STATE(); case 609: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(238); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(414); END_STATE(); case 610: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(574); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(551); END_STATE(); case 611: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(566); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(409); END_STATE(); case 612: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(571); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(609); END_STATE(); case 613: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(289); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(329); END_STATE(); case 614: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(459); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(492); END_STATE(); case 615: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(532); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(610); END_STATE(); case 616: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(596); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(186); END_STATE(); case 617: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(300); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(429); END_STATE(); case 618: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(264); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1459); END_STATE(); case 619: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(151); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1392); END_STATE(); case 620: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(309); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1393); END_STATE(); case 621: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(307); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1394); END_STATE(); case 622: - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(1232); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(573); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1461); END_STATE(); case 623: - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(1295); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1458); END_STATE(); case 624: - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(363); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(306); END_STATE(); case 625: - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(336); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1401); END_STATE(); case 626: - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1307); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1460); END_STATE(); case 627: - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1334); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(1428); END_STATE(); case 628: - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1335); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(618); END_STATE(); case 629: - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(202); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(677); END_STATE(); case 630: - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(367); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(267); END_STATE(); case 631: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1253); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(644); END_STATE(); case 632: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1293); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(394); END_STATE(); case 633: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1317); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(269); END_STATE(); case 634: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1332); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(334); END_STATE(); case 635: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1329); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(281); END_STATE(); case 636: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(625); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(266); END_STATE(); case 637: - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1294); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(356); END_STATE(); case 638: - if (lookahead == 'Z' || - lookahead == 'z') ADVANCE(131); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(357); END_STATE(); case 639: - if (lookahead == 'Z' || - lookahead == 'z') ADVANCE(175); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(181); END_STATE(); case 640: - if (eof) ADVANCE(645); - if (lookahead == '\n') SKIP(642) + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1503); END_STATE(); case 641: - if (eof) ADVANCE(645); - if (lookahead == '\n') SKIP(642) - if (lookahead == '\r') SKIP(640) + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1485); END_STATE(); case 642: - if (eof) ADVANCE(645); - if (lookahead == ' ') ADVANCE(30); - if (lookahead == '"') ADVANCE(1184); - if (lookahead == '\'') ADVANCE(1189); - if (lookahead == '(') ADVANCE(1193); - if (lookahead == ')') ADVANCE(1194); - if (lookahead == '*') ADVANCE(1208); - if (lookahead == '+') ADVANCE(1206); - if (lookahead == ',') ADVANCE(1256); - if (lookahead == '-') ADVANCE(1207); - if (lookahead == '.') ADVANCE(1179); - if (lookahead == '/') ADVANCE(663); - if (lookahead == ':') ADVANCE(1261); - if (lookahead == '<') ADVANCE(1209); - if (lookahead == '=') ADVANCE(1212); - if (lookahead == '>') ADVANCE(1213); - if (lookahead == 'N') ADVANCE(115); - if (lookahead == 'S') ADVANCE(103); - if (lookahead == '\\') SKIP(641) - if (lookahead == 'n') ADVANCE(250); - if (lookahead == 's') ADVANCE(253); - if (lookahead == '{') ADVANCE(664); - if (lookahead == '}') ADVANCE(670); - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(178); - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(256); - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(128); - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(258); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(133); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(339); - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(229); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(415); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(129); - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(130); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(315); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(141); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(598); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(194); if (lookahead == 'T' || - lookahead == 't') ADVANCE(330); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(439); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(331); - if (lookahead == '\t' || - lookahead == '\n' || - lookahead == '\r') ADVANCE(29); - if (lookahead == '\f' || - lookahead == 8203 || - lookahead == 8288 || - lookahead == 65279) SKIP(642) - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); + lookahead == 't') ADVANCE(1510); END_STATE(); case 643: - if (eof) ADVANCE(645); - if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(718); - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(944); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(915); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(983); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1074); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(834); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1003); - if (lookahead == '\t' || - lookahead == '\n' || - lookahead == '\f' || - lookahead == '\r' || - lookahead == ' ' || - lookahead == 8203 || - lookahead == 8288 || - lookahead == 65279) SKIP(643) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1454); END_STATE(); case 644: - if (eof) ADVANCE(645); - if (lookahead == '/') ADVANCE(63); - if (lookahead == '\\') ADVANCE(1178); - if (lookahead == '{') ADVANCE(664); - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(718); - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1017); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(915); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1015); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(983); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1502); + END_STATE(); + case 645: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1429); + END_STATE(); + case 646: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1453); + END_STATE(); + case 647: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1431); + END_STATE(); + case 648: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1437); + END_STATE(); + case 649: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1496); + END_STATE(); + case 650: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1444); + END_STATE(); + case 651: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1448); + END_STATE(); + case 652: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1515); + END_STATE(); + case 653: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1398); + END_STATE(); + case 654: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1432); + END_STATE(); + case 655: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1450); + END_STATE(); + case 656: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1479); + END_STATE(); + case 657: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1374); + END_STATE(); + case 658: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(594); + END_STATE(); + case 659: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(385); + END_STATE(); + case 660: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(142); + END_STATE(); + case 661: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(726); + END_STATE(); + case 662: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(398); + END_STATE(); + case 663: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(570); + END_STATE(); + case 664: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(77); + END_STATE(); + case 665: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(538); + END_STATE(); + case 666: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(182); + END_STATE(); + case 667: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(626); + END_STATE(); + case 668: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(622); + END_STATE(); + case 669: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(401); + END_STATE(); + case 670: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(190); + END_STATE(); + case 671: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(276); + END_STATE(); + case 672: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(171); + END_STATE(); + case 673: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(174); + END_STATE(); + case 674: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(331); + END_STATE(); + case 675: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(407); + END_STATE(); + case 676: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(703); + END_STATE(); + case 677: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(597); + END_STATE(); + case 678: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(237); + END_STATE(); + case 679: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(335); + END_STATE(); + case 680: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(336); + END_STATE(); + case 681: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(346); + END_STATE(); + case 682: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(415); + END_STATE(); + case 683: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(572); + END_STATE(); + case 684: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(420); + END_STATE(); + case 685: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(421); + END_STATE(); + case 686: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(196); + END_STATE(); + case 687: + if (lookahead == 'T' || + lookahead == 't') ADVANCE(422); + END_STATE(); + case 688: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(480); + END_STATE(); + case 689: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(365); + END_STATE(); + case 690: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(632); + END_STATE(); + case 691: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(472); + END_STATE(); + case 692: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(473); + END_STATE(); + case 693: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(474); + END_STATE(); + case 694: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(596); + END_STATE(); + case 695: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(475); + END_STATE(); + case 696: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(274); + END_STATE(); + case 697: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(530); + END_STATE(); + case 698: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(657); + END_STATE(); + case 699: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(647); + END_STATE(); + case 700: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(654); + END_STATE(); + case 701: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(513); + END_STATE(); + case 702: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(410); + END_STATE(); + case 703: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(606); + END_STATE(); + case 704: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(522); + END_STATE(); + case 705: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(608); + END_STATE(); + case 706: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(338); + END_STATE(); + case 707: + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(683); + END_STATE(); + case 708: + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(302); + END_STATE(); + case 709: + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(169); + END_STATE(); + case 710: + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(354); + END_STATE(); + case 711: + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(355); + END_STATE(); + case 712: + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1403); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(656); + END_STATE(); + case 713: + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1482); + END_STATE(); + case 714: + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(419); + END_STATE(); + case 715: + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(389); + END_STATE(); + case 716: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(1498); + END_STATE(); + case 717: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(1524); + END_STATE(); + case 718: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(1525); + END_STATE(); + case 719: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(402); + END_STATE(); + case 720: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(232); + END_STATE(); + case 721: + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(426); + END_STATE(); + case 722: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1427); + END_STATE(); + case 723: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1480); + END_STATE(); + case 724: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1508); + END_STATE(); + case 725: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1522); + END_STATE(); + case 726: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1452); + END_STATE(); + case 727: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1520); + END_STATE(); + case 728: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(715); + END_STATE(); + case 729: + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1481); + END_STATE(); + case 730: + if (lookahead == 'Z' || + lookahead == 'z') ADVANCE(143); + END_STATE(); + case 731: + if (lookahead == 'Z' || + lookahead == 'z') ADVANCE(193); + END_STATE(); + case 732: + if (eof) ADVANCE(737); + if (lookahead == '\n') SKIP(734) + END_STATE(); + case 733: + if (eof) ADVANCE(737); + if (lookahead == '\n') SKIP(734) + if (lookahead == '\r') SKIP(732) + END_STATE(); + case 734: + if (eof) ADVANCE(737); + if (lookahead == ' ') ADVANCE(30); + if (lookahead == '"') ADVANCE(1354); + if (lookahead == '\'') ADVANCE(1359); + if (lookahead == '(') ADVANCE(1363); + if (lookahead == ')') ADVANCE(1364); + if (lookahead == '*') ADVANCE(1378); + if (lookahead == '+') ADVANCE(1376); + if (lookahead == ',') ADVANCE(1430); + if (lookahead == '-') ADVANCE(1377); + if (lookahead == '.') ADVANCE(1349); + if (lookahead == '/') ADVANCE(755); + if (lookahead == ':') ADVANCE(1435); + if (lookahead == '<') ADVANCE(1379); + if (lookahead == '=') ADVANCE(1382); + if (lookahead == '>') ADVANCE(1383); + if (lookahead == 'L') ADVANCE(118); + if (lookahead == 'N') ADVANCE(124); + if (lookahead == 'S') ADVANCE(112); + if (lookahead == '\\') SKIP(733) + if (lookahead == 'l') ADVANCE(138); + if (lookahead == 'n') ADVANCE(288); + if (lookahead == 's') ADVANCE(291); + if (lookahead == '{') ADVANCE(756); + if (lookahead == '}') ADVANCE(762); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(201); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(305); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(139); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(140); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(141); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(391); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(264); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(476); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(146); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(362); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(152); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(219); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(387); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(503); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(534); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(381); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r') ADVANCE(29); + if (lookahead == '\f' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(734) + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); + END_STATE(); + case 735: + if (eof) ADVANCE(737); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(817); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(947); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1075); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1049); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1124); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1114); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1074); + lookahead == 'p') ADVANCE(1225); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(834); + lookahead == 'r') ADVANCE(949); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1003); + lookahead == 'u') ADVANCE(1142); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -10766,4912 +11965,5681 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) SKIP(644) - if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1178); + lookahead == 65279) SKIP(735) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); END_STATE(); - case 645: + case 736: + if (eof) ADVANCE(737); + if (lookahead == '/') ADVANCE(63); + if (lookahead == '\\') ADVANCE(1348); + if (lookahead == '{') ADVANCE(756); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(817); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(947); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1049); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1124); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1114); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(1225); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(949); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1142); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\f' || + lookahead == '\r' || + lookahead == ' ' || + lookahead == 8203 || + lookahead == 8288 || + lookahead == 65279) SKIP(736) + if (('A' <= lookahead && lookahead <= 'z')) ADVANCE(1348); + END_STATE(); + case 737: ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); - case 646: + case 738: ACCEPT_TOKEN(sym_file_name); END_STATE(); - case 647: + case 739: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); END_STATE(); - case 648: + case 740: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead != 0) ADVANCE(65); END_STATE(); - case 649: + case 741: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); - if (lookahead == '.') ADVANCE(127); + if (lookahead == '.') ADVANCE(137); if (('-' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(89); + lookahead == '|') ADVANCE(95); END_STATE(); - case 650: + case 742: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); if (lookahead != 0 && lookahead != '"' && - lookahead != '\\') ADVANCE(1187); + lookahead != '\\') ADVANCE(1357); END_STATE(); - case 651: + case 743: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); if (lookahead != 0 && lookahead != '\'' && - lookahead != '\\') ADVANCE(1192); + lookahead != '\\') ADVANCE(1362); END_STATE(); - case 652: + case 744: ACCEPT_TOKEN(anon_sym_SLASH_SLASH); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 653: + case 745: ACCEPT_TOKEN(aux_sym_comment_token1); - if (lookahead == '\r') ADVANCE(656); + if (lookahead == '\r') ADVANCE(748); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 654: + case 746: ACCEPT_TOKEN(aux_sym_comment_token1); - if (lookahead == '*') ADVANCE(661); - if (lookahead == '/') ADVANCE(652); + if (lookahead == '*') ADVANCE(753); + if (lookahead == '/') ADVANCE(744); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 655: + case 747: ACCEPT_TOKEN(aux_sym_comment_token1); - if (lookahead == '/') ADVANCE(654); - if (lookahead == '\\') ADVANCE(653); - if (lookahead == '{') ADVANCE(668); + if (lookahead == '/') ADVANCE(746); + if (lookahead == '\\') ADVANCE(745); + if (lookahead == '{') ADVANCE(760); if (lookahead == '\t' || lookahead == '\f' || lookahead == '\r' || lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) ADVANCE(655); + lookahead == 65279) ADVANCE(747); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 656: + case 748: ACCEPT_TOKEN(aux_sym_comment_token1); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 657: + case 749: ACCEPT_TOKEN(anon_sym_SLASH_STAR); END_STATE(); - case 658: + case 750: ACCEPT_TOKEN(anon_sym_SLASH_STAR); - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead != 0 && lookahead != '/') ADVANCE(65); END_STATE(); - case 659: + case 751: ACCEPT_TOKEN(anon_sym_SLASH_STAR); if (lookahead != 0 && lookahead != '"' && - lookahead != '\\') ADVANCE(1187); + lookahead != '\\') ADVANCE(1357); END_STATE(); - case 660: + case 752: ACCEPT_TOKEN(anon_sym_SLASH_STAR); if (lookahead != 0 && lookahead != '\'' && - lookahead != '\\') ADVANCE(1192); + lookahead != '\\') ADVANCE(1362); END_STATE(); - case 661: + case 753: ACCEPT_TOKEN(anon_sym_SLASH_STAR); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 662: + case 754: ACCEPT_TOKEN(aux_sym_comment_token2); - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead != 0 && lookahead != '/') ADVANCE(65); END_STATE(); - case 663: + case 755: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '*') ADVANCE(657); - if (lookahead == '/') ADVANCE(647); + if (lookahead == '*') ADVANCE(749); + if (lookahead == '/') ADVANCE(739); END_STATE(); - case 664: + case 756: ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); - case 665: + case 757: ACCEPT_TOKEN(anon_sym_LBRACE); - if (lookahead == '*') ADVANCE(662); + if (lookahead == '*') ADVANCE(754); if (lookahead != 0) ADVANCE(65); END_STATE(); - case 666: + case 758: ACCEPT_TOKEN(anon_sym_LBRACE); if (lookahead != 0 && lookahead != '"' && - lookahead != '\\') ADVANCE(1187); + lookahead != '\\') ADVANCE(1357); END_STATE(); - case 667: + case 759: ACCEPT_TOKEN(anon_sym_LBRACE); if (lookahead != 0 && lookahead != '\'' && - lookahead != '\\') ADVANCE(1192); + lookahead != '\\') ADVANCE(1362); END_STATE(); - case 668: + case 760: ACCEPT_TOKEN(anon_sym_LBRACE); if (lookahead != 0 && - lookahead != '\n') ADVANCE(656); + lookahead != '\n') ADVANCE(748); END_STATE(); - case 669: + case 761: ACCEPT_TOKEN(anon_sym_AMP); END_STATE(); - case 670: + case 762: ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); - case 671: + case 763: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '\n') ADVANCE(1199); + if (lookahead == '\n') ADVANCE(1369); if (lookahead == '\r') ADVANCE(2); - if (lookahead == ' ') ADVANCE(1198); + if (lookahead == ' ') ADVANCE(1368); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 672: + case 764: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '\n') ADVANCE(1196); + if (lookahead == '\n') ADVANCE(1366); if (lookahead == '\r') ADVANCE(4); - if (lookahead == ' ') ADVANCE(1195); + if (lookahead == ' ') ADVANCE(1365); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 673: + case 765: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(690); + if (lookahead == '-') ADVANCE(785); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 674: + case 766: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(854); + if (lookahead == '-') ADVANCE(965); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 675: + case 767: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(716); + if (lookahead == '-') ADVANCE(815); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 676: + case 768: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(909); + if (lookahead == '-') ADVANCE(1044); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 677: + case 769: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(691); + if (lookahead == '-') ADVANCE(786); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 678: + case 770: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(1046); + if (lookahead == '-') ADVANCE(1003); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 679: + case 771: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '-') ADVANCE(1191); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 772: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(951); + if (lookahead == '-') ADVANCE(1081); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1234); + lookahead == 'd') ADVANCE(1405); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 680: + case 773: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(951); + if (lookahead == '-') ADVANCE(1081); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 681: + case 774: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(953); + if (lookahead == '-') ADVANCE(1088); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 682: + case 775: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(1138); + if (lookahead == '-') ADVANCE(1058); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 683: + case 776: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(952); + if (lookahead == '-') ADVANCE(825); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 684: + case 777: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(1030); + if (lookahead == '-') ADVANCE(1083); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 685: + case 778: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(926); + if (lookahead == '-') ADVANCE(1305); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 686: + case 779: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(913); + if (lookahead == '-') ADVANCE(1040); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 687: + case 780: ACCEPT_TOKEN(sym_identifier); - if (lookahead == '-') ADVANCE(910); + if (lookahead == '-') ADVANCE(1231); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(975); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 688: + case 781: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '-') ADVANCE(1175); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 782: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == '-') ADVANCE(1045); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 783: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'C') ADVANCE(706); + if (lookahead == 'C') ADVANCE(801); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1054); + lookahead == 'e') ADVANCE(1214); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(733); + lookahead == 'h') ADVANCE(831); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1011); if (lookahead == 'T' || - lookahead == 't') ADVANCE(726); + lookahead == 't') ADVANCE(828); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(758); + lookahead == 'u') ADVANCE(863); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 689: + case 784: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E') ADVANCE(1245); - if (lookahead == 'e') ADVANCE(1245); + if (lookahead == 'E') ADVANCE(1419); + if (lookahead == 'e') ADVANCE(1419); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 690: + case 785: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E') ADVANCE(711); - if (lookahead == 'e') ADVANCE(1085); + if (lookahead == 'E') ADVANCE(806); + if (lookahead == 'e') ADVANCE(1241); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1023); + lookahead == 'l') ADVANCE(1162); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(730); + lookahead == 'w') ADVANCE(834); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 691: + case 786: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E') ADVANCE(712); + if (lookahead == 'E') ADVANCE(807); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 692: + case 787: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'G') ADVANCE(1251); + if (lookahead == 'G') ADVANCE(1425); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 693: + case 788: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'I') ADVANCE(695); - if (lookahead == 'i') ADVANCE(933); + if (lookahead == 'I') ADVANCE(790); + if (lookahead == 'i') ADVANCE(1065); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(760); + lookahead == 'a') ADVANCE(865); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); + lookahead == 'e') ADVANCE(1386); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + lookahead == 't') ADVANCE(1385); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 694: + case 789: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'I') ADVANCE(698); + if (lookahead == 'I') ADVANCE(793); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 695: + case 790: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'K') ADVANCE(689); - if (lookahead == 'k') ADVANCE(814); + if (lookahead == 'K') ADVANCE(784); + if (lookahead == 'k') ADVANCE(922); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 696: + case 791: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'L') ADVANCE(694); + if (lookahead == 'L') ADVANCE(789); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 697: + case 792: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'L') ADVANCE(696); + if (lookahead == 'L') ADVANCE(791); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 698: + case 793: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'N') ADVANCE(692); + if (lookahead == 'N') ADVANCE(787); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 699: + case 794: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(673); - if (lookahead == 'o') ADVANCE(674); + if (lookahead == 'O') ADVANCE(765); + if (lookahead == 'o') ADVANCE(766); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1218); + lookahead == 'e') ADVANCE(1388); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 700: + case 795: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(697); + if (lookahead == 'O') ADVANCE(792); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 701: + case 796: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(709); + if (lookahead == 'O') ADVANCE(804); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 702: + case 797: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(708); - if (lookahead == 'o') ADVANCE(1060); + if (lookahead == 'O') ADVANCE(803); + if (lookahead == 'o') ADVANCE(1207); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 703: + case 798: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(677); + if (lookahead == 'O') ADVANCE(769); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1218); + lookahead == 'e') ADVANCE(1388); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 704: + case 799: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(677); + if (lookahead == 'O') ADVANCE(769); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); + lookahead == 'e') ADVANCE(1387); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 705: + case 800: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O') ADVANCE(677); + if (lookahead == 'O') ADVANCE(769); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 706: + case 801: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(700); + if (lookahead == 'R') ADVANCE(795); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 707: + case 802: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(702); - if (lookahead == 'r') ADVANCE(1034); + if (lookahead == 'R') ADVANCE(797); + if (lookahead == 'r') ADVANCE(1174); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 708: + case 803: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(1306); - if (lookahead == 'r') ADVANCE(1306); + if (lookahead == 'R') ADVANCE(1497); + if (lookahead == 'r') ADVANCE(1497); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 709: + case 804: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(1280); + if (lookahead == 'R') ADVANCE(1466); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 710: + case 805: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(701); + if (lookahead == 'R') ADVANCE(796); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 711: + case 806: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(707); - if (lookahead == 'r') ADVANCE(1081); + if (lookahead == 'R') ADVANCE(802); + if (lookahead == 'r') ADVANCE(1237); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 712: + case 807: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'R') ADVANCE(710); + if (lookahead == 'R') ADVANCE(805); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 713: + case 808: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'Y') ADVANCE(1500); + if (lookahead == 'y') ADVANCE(1500); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1010); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1127); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(950); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1002); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 809: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(760); + lookahead == 'a') ADVANCE(865); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); + lookahead == 'e') ADVANCE(1386); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(933); + lookahead == 'i') ADVANCE(1065); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + lookahead == 't') ADVANCE(1385); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 714: + case 810: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(770); + lookahead == 'a') ADVANCE(886); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(723); + lookahead == 'l') ADVANCE(821); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(942); + lookahead == 'o') ADVANCE(1073); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 715: + case 811: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1130); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1014); + lookahead == 'a') ADVANCE(1280); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1001); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1438); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 716: + case 812: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1160); - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1024); - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(717); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1035); - if (lookahead == '-' || - ('0' <= lookahead && lookahead <= '9') || - ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == 'a') ADVANCE(875); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1253); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(892); + if (lookahead == 'Q' || + lookahead == 'q') ADVANCE(1389); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1213); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(987); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(871); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); END_STATE(); - case 717: + case 813: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1171); + lookahead == 'a') ADVANCE(1293); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1279); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1016); + lookahead == 'i') ADVANCE(1154); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 718: + case 814: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1098); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(724); + lookahead == 'a') ADVANCE(780); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 719: + case 815: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(929); + lookahead == 'a') ADVANCE(1329); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(1164); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(816); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1183); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 720: + case 816: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1340); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1155); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 817: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(772); + lookahead == 'a') ADVANCE(1251); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1099); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(786); - if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1065); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(766); + lookahead == 'l') ADVANCE(822); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 721: + case 818: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(972); + lookahead == 'a') ADVANCE(1104); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(964); + lookahead == 'o') ADVANCE(1096); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 722: + case 819: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(972); + lookahead == 'a') ADVANCE(1104); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 723: + case 820: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1061); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 821: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1096); + lookahead == 'a') ADVANCE(1249); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1102); + lookahead == 'o') ADVANCE(1254); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 724: + case 822: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1096); + lookahead == 'a') ADVANCE(1249); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 725: + case 823: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(885); + lookahead == 'a') ADVANCE(1218); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1028); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(864); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 726: + case 824: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1012); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 825: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1008); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 826: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(866); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 827: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1121); + lookahead == 'a') ADVANCE(1203); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1041); + lookahead == 'o') ADVANCE(1032); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 828: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1281); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1186); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(847); + lookahead == 'r') ADVANCE(970); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 727: + case 829: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || lookahead == 'a') ADVANCE(1067); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(900); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(759); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 728: + case 830: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(761); + lookahead == 'a') ADVANCE(1097); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 729: + case 831: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1056); + lookahead == 'a') ADVANCE(1220); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 730: + case 832: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(914); + lookahead == 'a') ADVANCE(1068); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 731: + case 833: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(935); + lookahead == 'a') ADVANCE(1130); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 732: + case 834: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(936); + lookahead == 'a') ADVANCE(1041); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 733: + case 835: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1071); + lookahead == 'a') ADVANCE(1069); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 734: + case 836: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(965); + lookahead == 'a') ADVANCE(1283); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 735: + case 837: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(950); + lookahead == 'a') ADVANCE(1086); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 736: + case 838: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(937); + lookahead == 'a') ADVANCE(1291); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 737: + case 839: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(938); + lookahead == 'a') ADVANCE(1216); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 738: + case 840: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1001); + lookahead == 'a') ADVANCE(1269); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 739: + case 841: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1128); + lookahead == 'a') ADVANCE(1072); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 740: + case 842: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1113); + lookahead == 'a') ADVANCE(1294); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 741: + case 843: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(956); + lookahead == 'a') ADVANCE(1107); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 742: + case 844: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1068); + lookahead == 'a') ADVANCE(868); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 743: + case 845: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(941); + lookahead == 'a') ADVANCE(1039); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 744: + case 846: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1131); + lookahead == 'a') ADVANCE(1082); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 745: + case 847: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(762); + lookahead == 'a') ADVANCE(1139); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 746: + case 848: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(974); + lookahead == 'a') ADVANCE(1250); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 747: + case 849: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(912); + lookahead == 'a') ADVANCE(883); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 748: + case 850: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(949); + lookahead == 'a') ADVANCE(1013); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 749: + case 851: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1095); + lookahead == 'a') ADVANCE(885); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 750: + case 852: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(887); + lookahead == 'a') ADVANCE(1257); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 751: + case 853: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(780); + lookahead == 'a') ADVANCE(1290); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 752: + case 854: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1086); + lookahead == 'a') ADVANCE(1240); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 753: + case 855: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(764); + lookahead == 'a') ADVANCE(869); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 754: + case 856: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1137); + lookahead == 'a') ADVANCE(1300); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 755: + case 857: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(765); + lookahead == 'a') ADVANCE(870); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 756: + case 858: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1303); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 859: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(1304); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 860: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(890); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('B' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 861: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'A' || - lookahead == 'a') ADVANCE(1170); + lookahead == 'a') ADVANCE(1337); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1014); + lookahead == 'i') ADVANCE(1154); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('B' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 757: + case 862: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(1097); + lookahead == 'b') ADVANCE(1252); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(785); + lookahead == 'n') ADVANCE(891); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1244); + lookahead == 's') ADVANCE(1418); if (lookahead == 'V' || - lookahead == 'v') ADVANCE(852); + lookahead == 'v') ADVANCE(986); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 758: + case 863: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(675); + lookahead == 'b') ADVANCE(767); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 759: + case 864: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(962); + lookahead == 'b') ADVANCE(1079); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 760: + case 865: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(843); + lookahead == 'b') ADVANCE(955); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1105); + lookahead == 's') ADVANCE(1261); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 761: + case 866: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(855); + lookahead == 'b') ADVANCE(972); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 762: + case 867: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(958); + lookahead == 'b') ADVANCE(832); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 763: + case 868: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(732); + lookahead == 'b') ADVANCE(1090); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 764: + case 869: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(959); + lookahead == 'b') ADVANCE(1091); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 765: + case 870: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'B' || - lookahead == 'b') ADVANCE(960); + lookahead == 'b') ADVANCE(1092); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 766: + case 871: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(845); + lookahead == 'c') ADVANCE(956); if (lookahead == 'T' || - lookahead == 't') ADVANCE(864); + lookahead == 't') ADVANCE(991); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 767: + case 872: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1235); + lookahead == 'c') ADVANCE(1406); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 768: + case 873: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1238); + lookahead == 'c') ADVANCE(1409); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 769: + case 874: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1019); + lookahead == 'c') ADVANCE(1163); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(880); + lookahead == 'e') ADVANCE(1006); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 770: + case 875: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(891); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(815); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(775); + lookahead == 'c') ADVANCE(1015); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 771: + case 876: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(930); + lookahead == 'c') ADVANCE(1062); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 772: + case 877: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(888); + lookahead == 'c') ADVANCE(1063); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 773: + case 878: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(904); + lookahead == 'c') ADVANCE(1016); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 774: + case 879: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(931); + lookahead == 'c') ADVANCE(1064); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 775: + case 880: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(889); + lookahead == 'c') ADVANCE(963); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(974); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(985); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 776: + case 881: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(932); + lookahead == 'c') ADVANCE(963); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 777: + case 882: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(844); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(863); + lookahead == 'c') ADVANCE(1076); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 778: + case 883: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(844); + lookahead == 'c') ADVANCE(1272); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 779: + case 884: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(946); + lookahead == 'c') ADVANCE(969); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 780: + case 885: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1115); + lookahead == 'c') ADVANCE(945); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 781: + case 886: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(851); + lookahead == 'c') ADVANCE(1018); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(923); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(878); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 782: + case 887: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(894); + lookahead == 'c') ADVANCE(1284); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 783: + case 888: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1122); + lookahead == 'c') ADVANCE(1292); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 784: + case 889: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'C' || - lookahead == 'c') ADVANCE(1129); + lookahead == 'c') ADVANCE(1021); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 785: + case 890: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(1302); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 891: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1315); + lookahead == 'd') ADVANCE(1506); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1164); + lookahead == 'y') ADVANCE(1333); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 786: + case 892: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1180); + lookahead == 'd') ADVANCE(1350); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 787: + case 893: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1331); + lookahead == 'd') ADVANCE(1445); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 788: + case 894: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1237); + lookahead == 'd') ADVANCE(1396); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 789: + case 895: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(672); + lookahead == 'd') ADVANCE(1521); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 790: + case 896: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1018); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1052); + lookahead == 'd') ADVANCE(1456); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 791: + case 897: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1018); + lookahead == 'd') ADVANCE(1408); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 792: + case 898: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(685); + lookahead == 'd') ADVANCE(764); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 793: + case 899: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(1156); + lookahead == 'd') ADVANCE(1158); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1199); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 794: + case 900: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(874); + lookahead == 'd') ADVANCE(1158); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 795: + case 901: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(837); + lookahead == 'd') ADVANCE(775); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 796: + case 902: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(838); + lookahead == 'd') ADVANCE(1248); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 797: + case 903: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(846); + lookahead == 'd') ADVANCE(960); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 798: + case 904: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(886); + lookahead == 'd') ADVANCE(936); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 799: + case 905: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'D' || - lookahead == 'd') ADVANCE(961); + lookahead == 'd') ADVANCE(948); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 800: + case 906: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1216); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1215); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(951); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 801: + case 907: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1218); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(674); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(957); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 802: + case 908: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1218); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1014); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 803: + case 909: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1054); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(733); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(726); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(758); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1093); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 804: + case 910: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(1324); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 911: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(884); + lookahead == 'e') ADVANCE(1010); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1127); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(836); + lookahead == 'r') ADVANCE(950); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(879); + lookahead == 'u') ADVANCE(1002); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1309); + lookahead == 'y') ADVANCE(1500); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 805: + case 912: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(884); + lookahead == 'e') ADVANCE(1010); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 806: + case 913: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(773); + lookahead == 'e') ADVANCE(1386); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1385); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 914: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1388); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1264); + lookahead == 'o') ADVANCE(766); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 807: + case 915: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1221); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1022); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1220); + lookahead == 'e') ADVANCE(1388); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 808: + case 916: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1221); + lookahead == 'e') ADVANCE(1214); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(831); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1011); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1220); + lookahead == 't') ADVANCE(828); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(863); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 809: + case 917: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(970); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(840); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1265); + lookahead == 'e') ADVANCE(1391); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1161); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1390); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 810: + case 918: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(970); + lookahead == 'e') ADVANCE(1391); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1390); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 811: + case 919: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(947); + lookahead == 'e') ADVANCE(1078); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(731); + lookahead == 'n') ADVANCE(829); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1100); + lookahead == 'r') ADVANCE(1255); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 812: + case 920: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(947); + lookahead == 'e') ADVANCE(1078); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 813: + case 921: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(987); + lookahead == 'e') ADVANCE(1118); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(957); + lookahead == 'i') ADVANCE(1087); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 814: + case 922: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1245); + lookahead == 'e') ADVANCE(1419); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 815: + case 923: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1298); + lookahead == 'e') ADVANCE(1489); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 816: + case 924: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1260); + lookahead == 'e') ADVANCE(1434); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 817: + case 925: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(679); + lookahead == 'e') ADVANCE(772); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 818: + case 926: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1249); + lookahead == 'e') ADVANCE(1423); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 819: + case 927: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1286); + lookahead == 'e') ADVANCE(1472); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 820: + case 928: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1205); + lookahead == 'e') ADVANCE(1375); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 821: + case 929: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1301); + lookahead == 'e') ADVANCE(1492); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 822: + case 930: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1262); + lookahead == 'e') ADVANCE(1436); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 823: + case 931: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1333); + lookahead == 'e') ADVANCE(1412); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 824: + case 932: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1318); + lookahead == 'e') ADVANCE(1523); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 825: + case 933: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1236); + lookahead == 'e') ADVANCE(1509); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 826: + case 934: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1340); + lookahead == 'e') ADVANCE(1407); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 827: + case 935: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1241); + lookahead == 'e') ADVANCE(1526); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 828: + case 936: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1300); + lookahead == 'e') ADVANCE(1449); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 829: + case 937: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1266); + lookahead == 'e') ADVANCE(1415); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 830: + case 938: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1248); + lookahead == 'e') ADVANCE(1455); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 831: + case 939: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1323); + lookahead == 'e') ADVANCE(1491); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 832: + case 940: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1239); + lookahead == 'e') ADVANCE(1439); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 833: + case 941: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1285); + lookahead == 'e') ADVANCE(1422); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 834: + case 942: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1048); + lookahead == 'e') ADVANCE(1514); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 835: + case 943: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1217); + lookahead == 'e') ADVANCE(1410); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 836: + case 944: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(719); + lookahead == 'e') ADVANCE(1471); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 837: + case 945: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1165); + lookahead == 'e') ADVANCE(1447); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 838: + case 946: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1166); + lookahead == 'e') ADVANCE(1387); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 839: + case 947: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(676); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(993); + lookahead == 'e') ADVANCE(1001); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1438); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 840: + case 948: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(986); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1020); + lookahead == 'e') ADVANCE(1334); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 841: + case 949: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1161); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(674); + lookahead == 'e') ADVANCE(1195); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 842: + case 950: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1161); + lookahead == 'e') ADVANCE(820); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 843: + case 951: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(934); + lookahead == 'e') ADVANCE(1335); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 844: + case 952: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(793); + lookahead == 'e') ADVANCE(768); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1128); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 845: + case 953: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1045); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1144); + lookahead == 'e') ADVANCE(1330); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(766); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 846: + case 954: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1167); + lookahead == 'e') ADVANCE(1330); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 847: + case 955: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(734); + lookahead == 'e') ADVANCE(1066); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 848: + case 956: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1169); + lookahead == 'e') ADVANCE(1190); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1312); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 849: + case 957: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1090); + lookahead == 'e') ADVANCE(1336); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 850: + case 958: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(788); + lookahead == 'e') ADVANCE(1117); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1160); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 851: + case 959: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(684); + lookahead == 'e') ADVANCE(1339); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 852: + case 960: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1069); + lookahead == 'e') ADVANCE(779); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 853: + case 961: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1057); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1106); + lookahead == 'e') ADVANCE(1224); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 854: + case 962: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1085); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1023); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(730); + lookahead == 'e') ADVANCE(1245); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 855: + case 963: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(939); + lookahead == 'e') ADVANCE(910); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 856: + case 964: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1066); + lookahead == 'e') ADVANCE(1204); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1262); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 857: + case 965: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1059); + lookahead == 'e') ADVANCE(1241); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(1162); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(834); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 858: + case 966: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1061); + lookahead == 'e') ADVANCE(1094); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 859: + case 967: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1132); + lookahead == 'e') ADVANCE(777); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 860: + case 968: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1124); + lookahead == 'e') ADVANCE(897); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 861: + case 969: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1083); + lookahead == 'e') ADVANCE(781); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 862: + case 970: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(999); + lookahead == 'e') ADVANCE(830); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 863: + case 971: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(784); + lookahead == 'e') ADVANCE(1215); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 864: + case 972: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1005); + lookahead == 'e') ADVANCE(1070); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 865: + case 973: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(683); + lookahead == 'e') ADVANCE(1206); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 866: + case 974: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1077); + lookahead == 'e') ADVANCE(1228); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 867: + case 975: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1084); + lookahead == 'e') ADVANCE(1271); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 868: + case 976: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(740); + lookahead == 'e') ADVANCE(1208); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 869: + case 977: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(981); + lookahead == 'e') ADVANCE(1298); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 870: + case 978: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(680); + lookahead == 'e') ADVANCE(1209); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 871: + case 979: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1078); + lookahead == 'e') ADVANCE(1219); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 872: + case 980: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1008); + lookahead == 'e') ADVANCE(1286); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 873: + case 981: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(1075); + lookahead == 'e') ADVANCE(1102); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(958); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1474); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(833); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 874: + case 982: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(686); + lookahead == 'e') ADVANCE(1102); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 875: + case 983: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1085); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 984: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1132); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 985: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(888); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 986: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1223); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 987: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1137); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 988: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1229); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 989: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(773); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 990: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1111); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 991: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1141); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 992: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(840); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 993: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1239); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 994: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1232); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 995: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1146); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 996: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(1226); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 997: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(687); + lookahead == 'e') ADVANCE(782); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(993); + lookahead == 'i') ADVANCE(1128); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 876: + case 998: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); + lookahead == 'f') ADVANCE(1504); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); + lookahead == 'n') ADVANCE(1475); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(671); + lookahead == 'r') ADVANCE(763); if (lookahead == 'T' || - lookahead == 't') ADVANCE(895); + lookahead == 't') ADVANCE(1023); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1120); + lookahead == 'u') ADVANCE(1278); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(961); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 877: + case 999: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); + lookahead == 'f') ADVANCE(1504); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); + lookahead == 'n') ADVANCE(1475); if (lookahead == 'T' || - lookahead == 't') ADVANCE(895); + lookahead == 't') ADVANCE(1023); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1120); + lookahead == 'u') ADVANCE(1278); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(961); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 878: + case 1000: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1313); + lookahead == 'f') ADVANCE(1504); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 879: + case 1001: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(882); + lookahead == 'f') ADVANCE(1414); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 880: + case 1002: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1007); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1003: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1043); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1004: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(851); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1005: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(1178); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1006: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(866); + lookahead == 'f') ADVANCE(988); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(856); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(868); + lookahead == 'p') ADVANCE(992); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1063); + lookahead == 't') ADVANCE(1212); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 881: + case 1007: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(1036); + lookahead == 'f') ADVANCE(973); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 882: + case 1008: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'F' || - lookahead == 'f') ADVANCE(857); + lookahead == 'f') ADVANCE(1299); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 883: + case 1009: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(1314); + lookahead == 'g') ADVANCE(1505); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 884: + case 1010: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(907); + lookahead == 'g') ADVANCE(1035); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 885: + case 1011: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(824); + lookahead == 'g') ADVANCE(1138); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 886: + case 1012: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(860); + lookahead == 'g') ADVANCE(933); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 887: + case 1013: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(831); + lookahead == 'g') ADVANCE(942); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 888: + case 1014: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(980); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1015: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(1310); + lookahead == 'h') ADVANCE(1501); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 889: + case 1016: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(1316); + lookahead == 'h') ADVANCE(1507); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 890: + case 1017: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(813); + lookahead == 'h') ADVANCE(921); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1064); + lookahead == 'o') ADVANCE(1217); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 891: + case 1018: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(818); + lookahead == 'h') ADVANCE(926); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 892: + case 1019: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(738); + lookahead == 'h') ADVANCE(1047); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 893: + case 1020: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(920); + lookahead == 'h') ADVANCE(847); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 894: + case 1021: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(849); + lookahead == 'h') ADVANCE(962); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 895: + case 1022: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(856); + lookahead == 'h') ADVANCE(1166); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 896: + case 1023: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(752); + lookahead == 'h') ADVANCE(971); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 897: + case 1024: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(871); + lookahead == 'h') ADVANCE(994); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 898: + case 1025: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'H' || - lookahead == 'h') ADVANCE(873); + lookahead == 'h') ADVANCE(996); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 899: + case 1026: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(854); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1027: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(811); + lookahead == 'i') ADVANCE(919); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1055); + lookahead == 'o') ADVANCE(1202); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(721); + lookahead == 'r') ADVANCE(818); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(995); + lookahead == 'u') ADVANCE(1126); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 900: + case 1028: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(976); + lookahead == 'i') ADVANCE(1105); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(777); + lookahead == 'o') ADVANCE(880); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 901: + case 1029: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1177); + lookahead == 'i') ADVANCE(1347); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 902: + case 1030: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1159); + lookahead == 'i') ADVANCE(1328); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1288); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 903: + case 1031: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(767); + lookahead == 'i') ADVANCE(872); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 904: + case 1032: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(979); + lookahead == 'i') ADVANCE(894); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 905: + case 1033: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(768); + lookahead == 'i') ADVANCE(1106); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 906: + case 1034: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(798); + lookahead == 'i') ADVANCE(873); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 907: + case 1035: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(996); + lookahead == 'i') ADVANCE(1131); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 908: + case 1036: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(975); + lookahead == 'i') ADVANCE(846); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 909: + case 1037: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1009); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(906); + lookahead == 'i') ADVANCE(908); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 910: + case 1038: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1009); + lookahead == 'i') ADVANCE(1171); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 911: + case 1039: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1028); + lookahead == 'i') ADVANCE(1136); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 912: + case 1040: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1000); + lookahead == 'i') ADVANCE(1129); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 913: + case 1041: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(994); + lookahead == 'i') ADVANCE(1270); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 914: + case 1042: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1114); + lookahead == 'i') ADVANCE(1235); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 915: + case 1043: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1013); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1055); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(995); + lookahead == 'i') ADVANCE(983); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 916: + case 1044: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1125); + lookahead == 'i') ADVANCE(1148); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1037); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 917: + case 1045: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1080); + lookahead == 'i') ADVANCE(1148); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 918: + case 1046: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(812); - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(722); + lookahead == 'i') ADVANCE(1327); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 919: + case 1047: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(812); + lookahead == 'i') ADVANCE(1087); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 920: + case 1048: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(957); + lookahead == 'i') ADVANCE(904); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 921: + case 1049: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(748); + lookahead == 'i') ADVANCE(1150); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1202); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1126); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 922: + case 1050: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1103); + lookahead == 'i') ADVANCE(1172); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 923: + case 1051: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1033); + lookahead == 'i') ADVANCE(920); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(819); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 924: + case 1052: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(736); + lookahead == 'i') ADVANCE(920); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 925: + case 1053: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(977); + lookahead == 'i') ADVANCE(1258); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 926: + case 1054: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1011); + lookahead == 'i') ADVANCE(1173); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 927: + case 1055: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(978); + lookahead == 'i') ADVANCE(1176); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 928: + case 1056: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(980); + lookahead == 'i') ADVANCE(1177); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 929: + case 1057: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1308); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1108); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 930: + case 1058: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1149); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1059: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1109); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1060: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1110); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1061: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1302); + lookahead == 'k') ADVANCE(1499); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 931: + case 1062: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1303); + lookahead == 'k') ADVANCE(1493); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 932: + case 1063: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'K' || - lookahead == 'k') ADVANCE(1304); + lookahead == 'k') ADVANCE(1494); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 933: + case 1064: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'K' || - lookahead == 'k') ADVANCE(814); + lookahead == 'k') ADVANCE(1495); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 934: + case 1065: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1228); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(922); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 935: + case 1066: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1278); + lookahead == 'l') ADVANCE(1399); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 936: + case 1067: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1233); + lookahead == 'l') ADVANCE(1464); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 937: + case 1068: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1226); + lookahead == 'l') ADVANCE(1404); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 938: + case 1069: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1327); + lookahead == 'l') ADVANCE(1518); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 939: + case 1070: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1229); + lookahead == 'l') ADVANCE(1400); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 940: + case 1071: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1275); + lookahead == 'l') ADVANCE(1462); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 941: + case 1072: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1322); + lookahead == 'l') ADVANCE(1513); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 942: + case 1073: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1143); + lookahead == 'l') ADVANCE(1309); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1123); + lookahead == 'n') ADVANCE(1287); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1002); + lookahead == 'u') ADVANCE(1134); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 943: + case 1074: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1099); + lookahead == 'l') ADVANCE(1253); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(786); + lookahead == 'n') ADVANCE(892); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 944: + case 1075: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1099); + lookahead == 'l') ADVANCE(1253); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 945: + case 1076: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1174); + lookahead == 'l') ADVANCE(1312); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 946: + case 1077: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1144); + lookahead == 'l') ADVANCE(1343); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 947: + case 1078: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(787); + lookahead == 'l') ADVANCE(895); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 948: + case 1079: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1176); + lookahead == 'l') ADVANCE(1034); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 949: + case 1080: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(901); + lookahead == 'l') ADVANCE(1346); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 950: + case 1081: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1092); + lookahead == 'l') ADVANCE(1165); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 951: + case 1082: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1026); + lookahead == 'l') ADVANCE(1029); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 952: + case 1083: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1027); + lookahead == 'l') ADVANCE(1167); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 953: + case 1084: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(728); + lookahead == 'l') ADVANCE(990); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 954: + case 1085: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(869); + lookahead == 'l') ADVANCE(902); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 955: + case 1086: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(724); + lookahead == 'l') ADVANCE(1077); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 956: + case 1087: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(945); + lookahead == 'l') ADVANCE(930); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 957: + case 1088: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(822); + lookahead == 'l') ADVANCE(826); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 958: + case 1089: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(827); + lookahead == 'l') ADVANCE(822); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 959: + case 1090: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(830); + lookahead == 'l') ADVANCE(937); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 960: + case 1091: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(832); + lookahead == 'l') ADVANCE(941); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 961: + case 1092: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(833); + lookahead == 'l') ADVANCE(943); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 962: + case 1093: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(905); + lookahead == 'l') ADVANCE(944); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 963: + case 1094: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1042); - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1338); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(858); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 964: + case 1095: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1287); + lookahead == 'm') ADVANCE(1187); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 965: + case 1096: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1284); + lookahead == 'm') ADVANCE(1473); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 966: + case 1097: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1320); + lookahead == 'm') ADVANCE(1469); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 967: + case 1098: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1321); + lookahead == 'm') ADVANCE(1511); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 968: + case 1099: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1325); + lookahead == 'm') ADVANCE(1512); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 969: + case 1100: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1326); + lookahead == 'm') ADVANCE(1516); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 970: + case 1101: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1044); + lookahead == 'm') ADVANCE(1517); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 971: + case 1102: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(998); + lookahead == 'm') ADVANCE(1189); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 972: + case 1103: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(820); + lookahead == 'm') ADVANCE(1133); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 973: + case 1104: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(754); + lookahead == 'm') ADVANCE(928); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 974: + case 1105: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(859); + lookahead == 'm') ADVANCE(839); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(838); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 975: + case 1106: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1145); + lookahead == 'm') ADVANCE(1311); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 976: + case 1107: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(742); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(739); + lookahead == 'm') ADVANCE(977); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 977: + case 1108: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1146); + lookahead == 'm') ADVANCE(1313); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 978: + case 1109: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1148); + lookahead == 'm') ADVANCE(1314); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 979: + case 1110: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(735); + lookahead == 'm') ADVANCE(1315); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 980: + case 1111: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(1149); + lookahead == 'm') ADVANCE(995); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 981: + case 1112: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'M' || - lookahead == 'm') ADVANCE(872); + lookahead == 'm') ADVANCE(859); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 982: + case 1113: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(786); + lookahead == 'n') ADVANCE(892); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 983: + case 1114: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); + lookahead == 'n') ADVANCE(1475); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1120); + lookahead == 'u') ADVANCE(1278); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 984: + case 1115: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1288); + lookahead == 'n') ADVANCE(1475); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 985: + case 1116: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(790); + lookahead == 'n') ADVANCE(899); if (lookahead == 'S' || - lookahead == 's') ADVANCE(839); + lookahead == 's') ADVANCE(952); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 986: + case 1117: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1259); + lookahead == 'n') ADVANCE(1433); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 987: + case 1118: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1299); + lookahead == 'n') ADVANCE(1490); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(821); + lookahead == 'r') ADVANCE(929); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 988: + case 1119: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1268); + lookahead == 'n') ADVANCE(1441); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 989: + case 1120: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1270); + lookahead == 'n') ADVANCE(1443); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 990: + case 1121: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1252); + lookahead == 'n') ADVANCE(1487); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 991: + case 1122: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1267); + lookahead == 'n') ADVANCE(1457); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 992: + case 1123: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1336); + lookahead == 'n') ADVANCE(1426); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 993: + case 1124: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(883); + lookahead == 'n') ADVANCE(1193); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 994: + case 1125: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(881); + lookahead == 'n') ADVANCE(1440); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 995: + case 1126: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(783); + lookahead == 'n') ADVANCE(887); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 996: + case 1127: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1089); + lookahead == 'n') ADVANCE(893); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 997: + case 1128: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1123); + lookahead == 'n') ADVANCE(1009); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 998: + case 1129: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(681); + lookahead == 'n') ADVANCE(1005); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 999: + case 1130: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(781); + lookahead == 'n') ADVANCE(1260); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1000: + case 1131: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1091); + lookahead == 'n') ADVANCE(1244); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1001: + case 1132: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(799); + lookahead == 'n') ADVANCE(884); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1002: + case 1133: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1107); + lookahead == 'n') ADVANCE(774); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1003: + case 1134: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(791); + lookahead == 'n') ADVANCE(1263); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1004: + case 1135: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(789); + lookahead == 'n') ADVANCE(770); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1005: + case 1136: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1111); + lookahead == 'n') ADVANCE(1246); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1006: + case 1137: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(948); + lookahead == 'n') ADVANCE(1264); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1007: + case 1138: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1116); + lookahead == 'n') ADVANCE(836); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1008: + case 1139: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1127); + lookahead == 'n') ADVANCE(909); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1009: + case 1140: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(795); + lookahead == 'n') ADVANCE(1080); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1010: + case 1141: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1043); + lookahead == 'n') ADVANCE(1267); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1011: + case 1142: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(796); + lookahead == 'n') ADVANCE(900); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1012: + case 1143: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(797); + lookahead == 'n') ADVANCE(898); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1013: + case 1144: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(741); + lookahead == 'n') ADVANCE(931); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1014: + case 1145: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(925); + lookahead == 'n') ADVANCE(1273); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1015: + case 1146: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(1050); + lookahead == 'n') ADVANCE(1285); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1016: + case 1147: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(928); + lookahead == 'n') ADVANCE(1287); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1017: + case 1148: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1264); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(905); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1018: + case 1149: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1290); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(906); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1019: + case 1150: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(794); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(837); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1020: + case 1151: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1162); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(907); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1021: + case 1152: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1055); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1196); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1022: + case 1153: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(763); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1194); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1023: + case 1154: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(771); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1057); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1024: + case 1155: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(1060); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1156: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1155); + lookahead == 'o') ADVANCE(1438); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1025: + case 1157: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1157); + lookahead == 'o') ADVANCE(1032); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1026: + case 1158: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(774); + lookahead == 'o') ADVANCE(1477); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1027: + case 1159: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(776); + lookahead == 'o') ADVANCE(1202); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1028: + case 1160: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(989); + lookahead == 'o') ADVANCE(1331); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1029: + case 1161: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1058); + lookahead == 'o') ADVANCE(867); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1030: + case 1162: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1006); + lookahead == 'o') ADVANCE(876); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1031: + case 1163: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1032); + lookahead == 'o') ADVANCE(903); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1032: + case 1164: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(940); + lookahead == 'o') ADVANCE(1322); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1033: + case 1165: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(990); + lookahead == 'o') ADVANCE(877); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1034: + case 1166: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1060); + lookahead == 'o') ADVANCE(896); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1035: + case 1167: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1133); + lookahead == 'o') ADVANCE(879); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1036: + case 1168: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1073); + lookahead == 'o') ADVANCE(1205); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1037: + case 1169: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1142); + lookahead == 'o') ADVANCE(1170); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1038: + case 1170: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(778); + lookahead == 'o') ADVANCE(1071); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1039: + case 1171: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(997); + lookahead == 'o') ADVANCE(1120); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1040: + case 1172: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'O' || - lookahead == 'o') ADVANCE(1134); + lookahead == 'o') ADVANCE(1135); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1041: + case 1173: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1121); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1174: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1207); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1175: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1140); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1176: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1122); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1177: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1123); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1178: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1221); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1179: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1147); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1180: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1192); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1181: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(881); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1182: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1310); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1183: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1296); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1184: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1297); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1185: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(1325); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1186: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1296); + lookahead == 'p') ADVANCE(1484); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1042: + case 1187: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(954); + lookahead == 'p') ADVANCE(1084); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1043: + case 1188: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1147); + lookahead == 'p') ADVANCE(1316); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1044: + case 1189: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(682); + lookahead == 'p') ADVANCE(778); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1045: + case 1190: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1110); + lookahead == 'p') ADVANCE(1266); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1046: + case 1191: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1031); + lookahead == 'p') ADVANCE(1169); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1047: + case 1192: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1150); + lookahead == 'p') ADVANCE(776); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1048: + case 1193: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(868); + lookahead == 'p') ADVANCE(1319); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1151); + lookahead == 't') ADVANCE(979); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1049: + case 1194: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1153); + lookahead == 'p') ADVANCE(1319); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1050: + case 1195: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1154); + lookahead == 'p') ADVANCE(992); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1318); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1051: + case 1196: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(1320); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1197: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(1321); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1198: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1219); + lookahead == 'q') ADVANCE(1389); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1052: + case 1199: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Q' || - lookahead == 'q') ADVANCE(1152); + lookahead == 'q') ADVANCE(1317); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1053: + case 1200: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(671); + lookahead == 'r') ADVANCE(950); + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1500); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1054: + case 1201: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(921); + lookahead == 'r') ADVANCE(763); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1055: + case 1202: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1247); + lookahead == 'r') ADVANCE(1421); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1056: + case 1203: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1242); + lookahead == 'r') ADVANCE(1416); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1057: + case 1204: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1172); + lookahead == 'r') ADVANCE(1341); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1058: + case 1205: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1289); + lookahead == 'r') ADVANCE(1476); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1059: + case 1206: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1246); + lookahead == 'r') ADVANCE(1420); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1060: + case 1207: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1306); + lookahead == 'r') ADVANCE(1497); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1061: + case 1208: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1269); + lookahead == 'r') ADVANCE(1442); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1062: + case 1209: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(836); - if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1309); + lookahead == 'r') ADVANCE(1486); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1063: + case 1210: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1173); + lookahead == 'r') ADVANCE(833); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1211: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1030); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1070); + lookahead == 'u') ADVANCE(864); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1064: + case 1212: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(792); + lookahead == 'r') ADVANCE(1342); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1222); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1065: + case 1213: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1029); + lookahead == 'r') ADVANCE(1168); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1066: + case 1214: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1163); + lookahead == 'r') ADVANCE(1036); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1451); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1067: + case 1215: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(746); + lookahead == 'r') ADVANCE(1332); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1068: + case 1216: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1175); + lookahead == 'r') ADVANCE(1344); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1069: + case 1217: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(725); + lookahead == 'r') ADVANCE(901); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1070: + case 1218: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(988); + lookahead == 'r') ADVANCE(843); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1071: + case 1219: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(817); + lookahead == 'r') ADVANCE(1004); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1072: + case 1220: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(751); + lookahead == 'r') ADVANCE(925); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1073: + case 1221: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(973); + lookahead == 'r') ADVANCE(1112); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1074: + case 1222: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1038); + lookahead == 'r') ADVANCE(1119); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1075: + case 1223: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(821); + lookahead == 'r') ADVANCE(824); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1076: + case 1224: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(991); + lookahead == 'r') ADVANCE(1236); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1077: + case 1225: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(862); + lookahead == 'r') ADVANCE(1181); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1078: + case 1226: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(826); + lookahead == 'r') ADVANCE(929); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1079: + case 1227: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(829); + lookahead == 'r') ADVANCE(849); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1080: + case 1228: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1100); + lookahead == 'r') ADVANCE(1282); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1081: + case 1229: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1034); + lookahead == 'r') ADVANCE(984); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1082: + case 1230: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(722); + lookahead == 'r') ADVANCE(1125); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1083: + case 1231: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(916); + lookahead == 'r') ADVANCE(966); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1084: + case 1232: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(750); + lookahead == 'r') ADVANCE(935); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1085: + case 1233: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(1081); + lookahead == 'r') ADVANCE(938); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1086: + case 1234: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'R' || - lookahead == 'r') ADVANCE(870); + lookahead == 'r') ADVANCE(940); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1087: + case 1235: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1244); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1255); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1088: + case 1236: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'S' || - lookahead == 's') ADVANCE(1272); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1048); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1089: + case 1237: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1174); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1238: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(819); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1239: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(850); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1240: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(989); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1241: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(1237); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1242: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1222); + lookahead == 's') ADVANCE(1418); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1090: + case 1243: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1223); + lookahead == 's') ADVANCE(1459); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1091: + case 1244: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1224); + lookahead == 's') ADVANCE(1392); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1092: + case 1245: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1230); + lookahead == 's') ADVANCE(1393); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1093: + case 1246: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1273); + lookahead == 's') ADVANCE(1394); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1094: + case 1247: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1274); + lookahead == 's') ADVANCE(1461); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1095: + case 1248: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1105); + lookahead == 's') ADVANCE(1458); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1096: + case 1249: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1088); + lookahead == 's') ADVANCE(1243); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1097: + case 1250: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1126); + lookahead == 's') ADVANCE(1261); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1098: + case 1251: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(815); + lookahead == 's') ADVANCE(923); if (lookahead == 'T' || - lookahead == 't') ADVANCE(775); + lookahead == 't') ADVANCE(878); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1099: + case 1252: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(816); + lookahead == 's') ADVANCE(1295); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1100: + case 1253: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1108); + lookahead == 's') ADVANCE(924); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1101: + case 1254: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(902); + lookahead == 's') ADVANCE(927); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1102: + case 1255: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(819); + lookahead == 's') ADVANCE(1265); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1103: + case 1256: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(828); + lookahead == 's') ADVANCE(1046); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1104: + case 1257: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'S' || - lookahead == 's') ADVANCE(875); + lookahead == 's') ADVANCE(975); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1105: + case 1258: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1312); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(939); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1106: + case 1259: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1297); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(997); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1107: + case 1260: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(1319); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(860); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1108: + case 1261: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1311); + lookahead == 't') ADVANCE(1503); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1109: + case 1262: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1203); + lookahead == 't') ADVANCE(1485); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1110: + case 1263: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1255); + lookahead == 't') ADVANCE(1510); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1111: + case 1264: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1330); + lookahead == 't') ADVANCE(1454); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1112: + case 1265: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1257); + lookahead == 't') ADVANCE(1502); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1113: + case 1266: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1263); + lookahead == 't') ADVANCE(1429); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1114: + case 1267: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1305); + lookahead == 't') ADVANCE(1453); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1115: + case 1268: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1276); + lookahead == 't') ADVANCE(1431); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1116: + case 1269: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1324); + lookahead == 't') ADVANCE(1437); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1117: + case 1270: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1258); + lookahead == 't') ADVANCE(1496); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1118: + case 1271: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1202); + lookahead == 't') ADVANCE(1444); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1119: + case 1272: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1292); + lookahead == 't') ADVANCE(1448); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1120: + case 1273: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1047); + lookahead == 't') ADVANCE(1515); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1121: + case 1274: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(903); + lookahead == 't') ADVANCE(1372); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1122: + case 1275: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(911); + lookahead == 't') ADVANCE(1373); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1123: + case 1276: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(747); + lookahead == 't') ADVANCE(1432); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1124: + case 1277: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(678); + lookahead == 't') ADVANCE(1479); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1125: + case 1278: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1093); + lookahead == 't') ADVANCE(1188); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1126: + case 1279: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1072); + lookahead == 't') ADVANCE(1022); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1127: + case 1280: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1094); + lookahead == 't') ADVANCE(814); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1128: + case 1281: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(825); + lookahead == 't') ADVANCE(1031); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1129: + case 1282: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(850); + lookahead == 't') ADVANCE(1345); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1130: + case 1283: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(782); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(908); + lookahead == 't') ADVANCE(1323); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1131: + case 1284: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(782); + lookahead == 't') ADVANCE(1038); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1132: + case 1285: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(858); + lookahead == 't') ADVANCE(1247); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1133: + case 1286: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(737); + lookahead == 't') ADVANCE(771); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1134: + case 1287: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(743); + lookahead == 't') ADVANCE(845); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1135: + case 1288: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(924); + lookahead == 't') ADVANCE(985); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1136: + case 1289: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(1049); + lookahead == 't') ADVANCE(1180); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1137: + case 1290: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(923); + lookahead == 't') ADVANCE(852); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1138: + case 1291: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'T' || - lookahead == 't') ADVANCE(753); + lookahead == 't') ADVANCE(934); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1139: + case 1292: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(758); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(968); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1140: + case 1293: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1120); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(889); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(1033); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1141: + case 1294: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(853); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(889); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1142: + case 1295: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1002); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1227); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1143: + case 1296: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(971); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(835); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1144: + case 1297: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1101); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(841); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1145: + case 1298: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(966); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(976); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1146: + case 1299: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(967); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(978); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1147: + case 1300: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1109); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1050); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1148: + case 1301: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(968); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1197); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1149: + case 1302: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(969); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1054); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1150: + case 1303: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1112); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1055); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1151: + case 1304: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1076); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(1056); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1152: + case 1305: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(823); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(855); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1153: + case 1306: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1117); + lookahead == 'u') ADVANCE(863); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1154: + case 1307: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1118); + lookahead == 'u') ADVANCE(964); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1155: + case 1308: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1007); + lookahead == 'u') ADVANCE(1278); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1156: + case 1309: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1079); + lookahead == 'u') ADVANCE(1103); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1157: + case 1310: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(1136); + lookahead == 'u') ADVANCE(1134); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1158: + case 1311: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(852); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1098); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1159: + case 1312: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(865); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1256); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1160: + case 1313: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(867); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1099); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1161: + case 1314: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(1232); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1100); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1162: + case 1315: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(1295); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1101); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1163: + case 1316: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(922); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1268); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1164: + case 1317: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'W' || - lookahead == 'w') ADVANCE(897); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(932); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1165: + case 1318: ACCEPT_TOKEN(sym_identifier); - if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1307); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1230); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1166: + case 1319: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1274); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1320: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1275); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1321: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1276); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1322: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1145); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1323: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1233); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1324: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1234); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1325: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(1301); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1326: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(986); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1327: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(967); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1328: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(838); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1329: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(993); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1330: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1403); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1331: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1482); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1332: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1053); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1333: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'W' || + lookahead == 'w') ADVANCE(1024); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1334: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1334); + lookahead == 'x') ADVANCE(1498); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1167: + case 1335: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1335); + lookahead == 'x') ADVANCE(1524); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1168: + case 1336: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(779); + lookahead == 'x') ADVANCE(1525); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1169: + case 1337: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(1119); + lookahead == 'x') ADVANCE(1033); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1170: + case 1338: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(908); + lookahead == 'x') ADVANCE(882); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1171: + case 1339: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'X' || - lookahead == 'x') ADVANCE(927); + lookahead == 'x') ADVANCE(1277); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1172: + case 1340: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'X' || + lookahead == 'x') ADVANCE(1059); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1341: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1253); + lookahead == 'y') ADVANCE(1427); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1173: + case 1342: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1293); + lookahead == 'y') ADVANCE(1480); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1174: + case 1343: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1317); + lookahead == 'y') ADVANCE(1508); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1175: + case 1344: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1332); + lookahead == 'y') ADVANCE(1522); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1176: + case 1345: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Y' || - lookahead == 'y') ADVANCE(1329); + lookahead == 'y') ADVANCE(1452); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1177: + case 1346: + ACCEPT_TOKEN(sym_identifier); + if (lookahead == 'Y' || + lookahead == 'y') ADVANCE(1520); + if (lookahead == '-' || + ('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'z') || + lookahead == '|') ADVANCE(1348); + END_STATE(); + case 1347: ACCEPT_TOKEN(sym_identifier); if (lookahead == 'Z' || - lookahead == 'z') ADVANCE(755); + lookahead == 'z') ADVANCE(857); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'y') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1178: + case 1348: ACCEPT_TOKEN(sym_identifier); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1179: + case 1349: ACCEPT_TOKEN(sym__terminator); END_STATE(); - case 1180: + case 1350: ACCEPT_TOKEN(aux_sym__block_terminator_token1); END_STATE(); - case 1181: + case 1351: ACCEPT_TOKEN(anon_sym_DOT); END_STATE(); - case 1182: + case 1352: ACCEPT_TOKEN(sym_null_expression); END_STATE(); - case 1183: + case 1353: ACCEPT_TOKEN(sym__integer_literal); - if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1183); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(1353); END_STATE(); - case 1184: + case 1354: ACCEPT_TOKEN(anon_sym_DQUOTE); END_STATE(); - case 1185: + case 1355: ACCEPT_TOKEN(aux_sym_double_quoted_string_token1); - if (lookahead == '*') ADVANCE(659); - if (lookahead == '/') ADVANCE(650); + if (lookahead == '*') ADVANCE(751); + if (lookahead == '/') ADVANCE(742); if (lookahead != 0 && lookahead != '"' && - lookahead != '\\') ADVANCE(1187); + lookahead != '\\') ADVANCE(1357); END_STATE(); - case 1186: + case 1356: ACCEPT_TOKEN(aux_sym_double_quoted_string_token1); - if (lookahead == '/') ADVANCE(1185); - if (lookahead == '\\') ADVANCE(17); - if (lookahead == '{') ADVANCE(666); + if (lookahead == '/') ADVANCE(1355); + if (lookahead == '\\') ADVANCE(15); + if (lookahead == '{') ADVANCE(758); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -15679,35 +17647,35 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) ADVANCE(1186); + lookahead == 65279) ADVANCE(1356); if (lookahead != 0 && - lookahead != '"') ADVANCE(1187); + lookahead != '"') ADVANCE(1357); END_STATE(); - case 1187: + case 1357: ACCEPT_TOKEN(aux_sym_double_quoted_string_token1); if (lookahead != 0 && lookahead != '"' && - lookahead != '\\') ADVANCE(1187); + lookahead != '\\') ADVANCE(1357); END_STATE(); - case 1188: + case 1358: ACCEPT_TOKEN(aux_sym_double_quoted_string_token2); END_STATE(); - case 1189: + case 1359: ACCEPT_TOKEN(anon_sym_SQUOTE); END_STATE(); - case 1190: + case 1360: ACCEPT_TOKEN(aux_sym_single_quoted_string_token1); - if (lookahead == '*') ADVANCE(660); - if (lookahead == '/') ADVANCE(651); + if (lookahead == '*') ADVANCE(752); + if (lookahead == '/') ADVANCE(743); if (lookahead != 0 && lookahead != '\'' && - lookahead != '\\') ADVANCE(1192); + lookahead != '\\') ADVANCE(1362); END_STATE(); - case 1191: + case 1361: ACCEPT_TOKEN(aux_sym_single_quoted_string_token1); - if (lookahead == '/') ADVANCE(1190); - if (lookahead == '\\') ADVANCE(18); - if (lookahead == '{') ADVANCE(667); + if (lookahead == '/') ADVANCE(1360); + if (lookahead == '\\') ADVANCE(16); + if (lookahead == '{') ADVANCE(759); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\f' || @@ -15715,496 +17683,537 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ' || lookahead == 8203 || lookahead == 8288 || - lookahead == 65279) ADVANCE(1191); + lookahead == 65279) ADVANCE(1361); if (lookahead != 0 && - lookahead != '\'') ADVANCE(1192); + lookahead != '\'') ADVANCE(1362); END_STATE(); - case 1192: + case 1362: ACCEPT_TOKEN(aux_sym_single_quoted_string_token1); if (lookahead != 0 && lookahead != '\'' && - lookahead != '\\') ADVANCE(1192); + lookahead != '\\') ADVANCE(1362); END_STATE(); - case 1193: + case 1363: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 1194: + case 1364: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); - case 1195: + case 1365: ACCEPT_TOKEN(aux_sym__logical_operator_token1); END_STATE(); - case 1196: + case 1366: ACCEPT_TOKEN(aux_sym__logical_operator_token2); END_STATE(); - case 1197: + case 1367: ACCEPT_TOKEN(aux_sym__logical_operator_token3); END_STATE(); - case 1198: + case 1368: ACCEPT_TOKEN(aux_sym__logical_operator_token4); END_STATE(); - case 1199: + case 1369: ACCEPT_TOKEN(aux_sym__logical_operator_token5); END_STATE(); - case 1200: + case 1370: ACCEPT_TOKEN(aux_sym__logical_operator_token6); END_STATE(); - case 1201: + case 1371: ACCEPT_TOKEN(aux_sym_unary_expression_token1); END_STATE(); - case 1202: + case 1372: ACCEPT_TOKEN(aux_sym_input_expression_token1); END_STATE(); - case 1203: + case 1373: ACCEPT_TOKEN(aux_sym_input_expression_token1); - if (lookahead == '-') ADVANCE(1025); + if (lookahead == '-') ADVANCE(1185); END_STATE(); - case 1204: + case 1374: ACCEPT_TOKEN(aux_sym_input_expression_token1); - if (lookahead == '-') ADVANCE(491); + if (lookahead == '-') ADVANCE(558); END_STATE(); - case 1205: + case 1375: ACCEPT_TOKEN(aux_sym_input_expression_token2); END_STATE(); - case 1206: + case 1376: ACCEPT_TOKEN(anon_sym_PLUS); END_STATE(); - case 1207: + case 1377: ACCEPT_TOKEN(anon_sym_DASH); END_STATE(); - case 1208: + case 1378: ACCEPT_TOKEN(anon_sym_STAR); END_STATE(); - case 1209: + case 1379: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '=') ADVANCE(1210); - if (lookahead == '>') ADVANCE(1211); + if (lookahead == '=') ADVANCE(1380); + if (lookahead == '>') ADVANCE(1381); END_STATE(); - case 1210: + case 1380: ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); - case 1211: + case 1381: ACCEPT_TOKEN(anon_sym_LT_GT); END_STATE(); - case 1212: + case 1382: ACCEPT_TOKEN(anon_sym_EQ); END_STATE(); - case 1213: + case 1383: ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(1214); + if (lookahead == '=') ADVANCE(1384); END_STATE(); - case 1214: + case 1384: ACCEPT_TOKEN(anon_sym_GT_EQ); END_STATE(); - case 1215: + case 1385: ACCEPT_TOKEN(aux_sym__comparison_operator_token1); END_STATE(); - case 1216: + case 1386: ACCEPT_TOKEN(aux_sym__comparison_operator_token2); END_STATE(); - case 1217: + case 1387: ACCEPT_TOKEN(aux_sym__comparison_operator_token3); END_STATE(); - case 1218: + case 1388: ACCEPT_TOKEN(aux_sym__comparison_operator_token3); if (lookahead == 'W' || - lookahead == 'w') ADVANCE(1232); + lookahead == 'w') ADVANCE(1403); END_STATE(); - case 1219: + case 1389: ACCEPT_TOKEN(aux_sym__comparison_operator_token4); END_STATE(); - case 1220: + case 1390: ACCEPT_TOKEN(aux_sym__comparison_operator_token5); END_STATE(); - case 1221: + case 1391: ACCEPT_TOKEN(aux_sym__comparison_operator_token6); END_STATE(); - case 1222: + case 1392: ACCEPT_TOKEN(aux_sym__comparison_operator_token7); END_STATE(); - case 1223: + case 1393: ACCEPT_TOKEN(aux_sym__comparison_operator_token8); END_STATE(); - case 1224: + case 1394: ACCEPT_TOKEN(aux_sym__comparison_operator_token9); END_STATE(); - case 1225: + case 1395: ACCEPT_TOKEN(aux_sym_include_argument_token1); END_STATE(); - case 1226: + case 1396: + ACCEPT_TOKEN(aux_sym_primitive_type_token1); + END_STATE(); + case 1397: ACCEPT_TOKEN(aux_sym_variable_tuning_token1); END_STATE(); - case 1227: + case 1398: ACCEPT_TOKEN(aux_sym_variable_tuning_token2); END_STATE(); - case 1228: + case 1399: ACCEPT_TOKEN(aux_sym_variable_tuning_token3); END_STATE(); - case 1229: + case 1400: ACCEPT_TOKEN(aux_sym_variable_tuning_token4); END_STATE(); - case 1230: + case 1401: ACCEPT_TOKEN(aux_sym_variable_tuning_token5); END_STATE(); - case 1231: + case 1402: ACCEPT_TOKEN(aux_sym_variable_tuning_token6); END_STATE(); - case 1232: + case 1403: ACCEPT_TOKEN(aux_sym_scope_tuning_token1); END_STATE(); - case 1233: + case 1404: ACCEPT_TOKEN(aux_sym_scope_tuning_token2); END_STATE(); - case 1234: + case 1405: ACCEPT_TOKEN(aux_sym_scope_tuning_token3); END_STATE(); - case 1235: + case 1406: ACCEPT_TOKEN(aux_sym_scope_tuning_token4); END_STATE(); - case 1236: + case 1407: ACCEPT_TOKEN(aux_sym_access_tuning_token1); END_STATE(); - case 1237: + case 1408: ACCEPT_TOKEN(aux_sym_access_tuning_token2); END_STATE(); - case 1238: + case 1409: ACCEPT_TOKEN(aux_sym_access_tuning_token3); END_STATE(); - case 1239: + case 1410: ACCEPT_TOKEN(aux_sym_serialization_tuning_token1); END_STATE(); - case 1240: + case 1411: ACCEPT_TOKEN(aux_sym_serialization_tuning_token2); END_STATE(); - case 1241: + case 1412: + ACCEPT_TOKEN(aux_sym_variable_definition_token1); + END_STATE(); + case 1413: + ACCEPT_TOKEN(aux_sym_variable_definition_token2); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(519); + END_STATE(); + case 1414: + ACCEPT_TOKEN(aux_sym_variable_definition_token2); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(1144); + END_STATE(); + case 1415: ACCEPT_TOKEN(aux_sym_variable_definition_token3); END_STATE(); - case 1242: + case 1416: ACCEPT_TOKEN(aux_sym_variable_definition_token4); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(745); + lookahead == 'i') ADVANCE(844); END_STATE(); - case 1243: + case 1417: ACCEPT_TOKEN(aux_sym_variable_definition_token4); if (lookahead == 'I' || - lookahead == 'i') ADVANCE(171); + lookahead == 'i') ADVANCE(194); END_STATE(); - case 1244: + case 1418: ACCEPT_TOKEN(aux_sym_variable_definition_token5); END_STATE(); - case 1245: + case 1419: ACCEPT_TOKEN(aux_sym_variable_definition_token6); END_STATE(); - case 1246: + case 1420: ACCEPT_TOKEN(aux_sym_buffer_definition_token1); END_STATE(); - case 1247: + case 1421: ACCEPT_TOKEN(aux_sym_buffer_definition_token2); END_STATE(); - case 1248: + case 1422: ACCEPT_TOKEN(aux_sym_buffer_definition_token3); END_STATE(); - case 1249: + case 1423: ACCEPT_TOKEN(aux_sym_query_definition_tuning_token1); END_STATE(); - case 1250: + case 1424: ACCEPT_TOKEN(anon_sym_SCROLLING); END_STATE(); - case 1251: + case 1425: ACCEPT_TOKEN(anon_sym_SCROLLING); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1252: + case 1426: ACCEPT_TOKEN(aux_sym_query_definition_tuning_token2); END_STATE(); - case 1253: + case 1427: ACCEPT_TOKEN(aux_sym_query_definition_token1); END_STATE(); - case 1254: + case 1428: ACCEPT_TOKEN(aux_sym_query_definition_token2); END_STATE(); - case 1255: + case 1429: ACCEPT_TOKEN(aux_sym_query_definition_token3); END_STATE(); - case 1256: + case 1430: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 1257: + case 1431: ACCEPT_TOKEN(aux_sym_argument_mode_token1); END_STATE(); - case 1258: + case 1432: ACCEPT_TOKEN(aux_sym_argument_mode_token2); END_STATE(); - case 1259: + case 1433: ACCEPT_TOKEN(aux_sym_if_statement_token2); END_STATE(); - case 1260: + case 1434: ACCEPT_TOKEN(aux_sym_else_if_statement_token1); END_STATE(); - case 1261: + case 1435: ACCEPT_TOKEN(anon_sym_COLON); END_STATE(); - case 1262: + case 1436: ACCEPT_TOKEN(aux_sym__while_condition_token1); END_STATE(); - case 1263: + case 1437: ACCEPT_TOKEN(aux_sym_repeat_statement_token1); END_STATE(); - case 1264: + case 1438: ACCEPT_TOKEN(aux_sym_do_while_statement_token1); END_STATE(); - case 1265: - ACCEPT_TOKEN(aux_sym_do_statement_token1); - END_STATE(); - case 1266: + case 1439: ACCEPT_TOKEN(aux_sym__procedure_terminator_token1); END_STATE(); - case 1267: + case 1440: ACCEPT_TOKEN(aux_sym_procedure_parameter_definition_token1); END_STATE(); - case 1268: + case 1441: ACCEPT_TOKEN(aux_sym_procedure_parameter_definition_token1); if (lookahead == 'S' || - lookahead == 's') ADVANCE(1271); + lookahead == 's') ADVANCE(1446); END_STATE(); - case 1269: + case 1442: ACCEPT_TOKEN(aux_sym_procedure_parameter_definition_token2); END_STATE(); - case 1270: + case 1443: ACCEPT_TOKEN(aux_sym__function_terminator_token1); END_STATE(); - case 1271: + case 1444: + ACCEPT_TOKEN(aux_sym_function_parameter_token1); + END_STATE(); + case 1445: + ACCEPT_TOKEN(aux_sym_function_parameter_token2); + END_STATE(); + case 1446: ACCEPT_TOKEN(aux_sym_function_statement_token1); END_STATE(); - case 1272: + case 1447: + ACCEPT_TOKEN(aux_sym_interface_statement_token1); + END_STATE(); + case 1448: + ACCEPT_TOKEN(aux_sym_property_tuning_token1); + END_STATE(); + case 1449: + ACCEPT_TOKEN(aux_sym_property_tuning_token2); + END_STATE(); + case 1450: + ACCEPT_TOKEN(aux_sym_getter_token1); + END_STATE(); + case 1451: + ACCEPT_TOKEN(aux_sym_setter_token1); + END_STATE(); + case 1452: + ACCEPT_TOKEN(aux_sym_property_definition_token1); + END_STATE(); + case 1453: + ACCEPT_TOKEN(aux_sym_property_definition_token2); + END_STATE(); + case 1454: + ACCEPT_TOKEN(aux_sym_event_definition_token1); + END_STATE(); + case 1455: + ACCEPT_TOKEN(aux_sym_event_definition_token2); + END_STATE(); + case 1456: + ACCEPT_TOKEN(aux_sym_method_definition_token1); + END_STATE(); + case 1457: + ACCEPT_TOKEN(aux_sym_data_relation_token1); + END_STATE(); + case 1458: + ACCEPT_TOKEN(aux_sym_data_relation_token2); + END_STATE(); + case 1459: ACCEPT_TOKEN(aux_sym_class_statement_token1); END_STATE(); - case 1273: - ACCEPT_TOKEN(aux_sym_class_statement_token2); + case 1460: + ACCEPT_TOKEN(aux_sym_inherits_token1); END_STATE(); - case 1274: + case 1461: ACCEPT_TOKEN(aux_sym_implements_token1); END_STATE(); - case 1275: + case 1462: ACCEPT_TOKEN(aux_sym_use_widget_pool_token1); END_STATE(); - case 1276: - ACCEPT_TOKEN(aux_sym_abstract_token1); - END_STATE(); - case 1277: + case 1463: ACCEPT_TOKEN(aux_sym_final_token1); END_STATE(); - case 1278: + case 1464: ACCEPT_TOKEN(aux_sym_final_token1); if (lookahead == 'L' || - lookahead == 'l') ADVANCE(1174); + lookahead == 'l') ADVANCE(1343); END_STATE(); - case 1279: + case 1465: ACCEPT_TOKEN(anon_sym_NO_DASHERROR); END_STATE(); - case 1280: + case 1466: ACCEPT_TOKEN(anon_sym_NO_DASHERROR); if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'z') || - lookahead == '|') ADVANCE(1178); + lookahead == '|') ADVANCE(1348); END_STATE(); - case 1281: + case 1467: ACCEPT_TOKEN(aux_sym_object_access_token1); END_STATE(); - case 1282: + case 1468: ACCEPT_TOKEN(aux_sym_stream_definition_token1); END_STATE(); - case 1283: + case 1469: ACCEPT_TOKEN(aux_sym_stream_definition_token1); - if (lookahead == '-') ADVANCE(335); + if (lookahead == '-') ADVANCE(1020); END_STATE(); - case 1284: + case 1470: ACCEPT_TOKEN(aux_sym_stream_definition_token1); - if (lookahead == '-') ADVANCE(892); + if (lookahead == '-') ADVANCE(383); END_STATE(); - case 1285: + case 1471: ACCEPT_TOKEN(aux_sym_input_close_statement_token1); END_STATE(); - case 1286: + case 1472: ACCEPT_TOKEN(aux_sym_input_close_statement_token2); END_STATE(); - case 1287: + case 1473: ACCEPT_TOKEN(aux_sym_input_stream_statement_token1); END_STATE(); - case 1288: + case 1474: + ACCEPT_TOKEN(aux_sym_output_stream_statement_token1); + END_STATE(); + case 1475: ACCEPT_TOKEN(aux_sym_on_error_phrase_token1); END_STATE(); - case 1289: + case 1476: ACCEPT_TOKEN(aux_sym_on_error_phrase_token2); END_STATE(); - case 1290: + case 1477: ACCEPT_TOKEN(aux_sym_on_error_phrase_token3); END_STATE(); - case 1291: + case 1478: ACCEPT_TOKEN(aux_sym_on_error_phrase_token4); END_STATE(); - case 1292: + case 1479: ACCEPT_TOKEN(aux_sym_on_error_phrase_token5); END_STATE(); - case 1293: + case 1480: ACCEPT_TOKEN(aux_sym_on_error_phrase_token6); END_STATE(); - case 1294: + case 1481: ACCEPT_TOKEN(aux_sym_on_error_phrase_token7); END_STATE(); - case 1295: + case 1482: ACCEPT_TOKEN(aux_sym_on_error_phrase_token8); END_STATE(); - case 1296: + case 1483: ACCEPT_TOKEN(aux_sym_on_stop_phrase_token1); END_STATE(); - case 1297: + case 1484: + ACCEPT_TOKEN(aux_sym_on_stop_phrase_token1); + if (lookahead == '-') ADVANCE(825); + END_STATE(); + case 1485: ACCEPT_TOKEN(aux_sym_on_quit_phrase_token1); END_STATE(); - case 1298: + case 1486: + ACCEPT_TOKEN(aux_sym_stop_after_phrase_token1); + END_STATE(); + case 1487: + ACCEPT_TOKEN(aux_sym_do_tuning_token1); + END_STATE(); + case 1488: + ACCEPT_TOKEN(anon_sym_BY); + END_STATE(); + case 1489: ACCEPT_TOKEN(aux_sym__case_terminator_token1); END_STATE(); - case 1299: + case 1490: ACCEPT_TOKEN(aux_sym_case_when_branch_token1); END_STATE(); - case 1300: + case 1491: ACCEPT_TOKEN(aux_sym_case_otherwise_branch_token1); END_STATE(); - case 1301: + case 1492: ACCEPT_TOKEN(aux_sym_where_clause_token1); END_STATE(); - case 1302: + case 1493: ACCEPT_TOKEN(aux_sym_query_tuning_token1); END_STATE(); - case 1303: + case 1494: ACCEPT_TOKEN(aux_sym_query_tuning_token2); END_STATE(); - case 1304: + case 1495: ACCEPT_TOKEN(aux_sym_query_tuning_token3); END_STATE(); - case 1305: + case 1496: ACCEPT_TOKEN(aux_sym_query_tuning_token4); END_STATE(); - case 1306: + case 1497: ACCEPT_TOKEN(aux_sym_query_tuning_token5); END_STATE(); - case 1307: + case 1498: ACCEPT_TOKEN(aux_sym_query_tuning_token6); END_STATE(); - case 1308: + case 1499: ACCEPT_TOKEN(aux_sym_sort_clause_token1); END_STATE(); - case 1309: + case 1500: ACCEPT_TOKEN(aux_sym_sort_clause_token2); END_STATE(); - case 1310: + case 1501: ACCEPT_TOKEN(aux_sym_for_phrase_token1); END_STATE(); - case 1311: + case 1502: ACCEPT_TOKEN(aux_sym_for_phrase_token2); END_STATE(); - case 1312: + case 1503: ACCEPT_TOKEN(aux_sym_for_phrase_token3); END_STATE(); - case 1313: + case 1504: ACCEPT_TOKEN(aux_sym_of_token1); END_STATE(); - case 1314: + case 1505: ACCEPT_TOKEN(aux_sym__using_first_token1); END_STATE(); - case 1315: + case 1506: ACCEPT_TOKEN(aux_sym__using_and_token1); END_STATE(); - case 1316: + case 1507: ACCEPT_TOKEN(aux_sym_catch_statement_token1); END_STATE(); - case 1317: + case 1508: ACCEPT_TOKEN(aux_sym_finally_statement_token1); END_STATE(); - case 1318: + case 1509: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token1); END_STATE(); - case 1319: + case 1510: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token2); END_STATE(); - case 1320: + case 1511: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token3); END_STATE(); - case 1321: + case 1512: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token4); END_STATE(); - case 1322: + case 1513: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token5); END_STATE(); - case 1323: + case 1514: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token6); END_STATE(); - case 1324: + case 1515: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token7); END_STATE(); - case 1325: + case 1516: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token8); END_STATE(); - case 1326: + case 1517: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token9); END_STATE(); - case 1327: + case 1518: ACCEPT_TOKEN(aux_sym_accumulate_aggregate_token10); END_STATE(); - case 1328: + case 1519: ACCEPT_TOKEN(anon_sym_); - if (lookahead == ' ') ADVANCE(1328); + if (lookahead == ' ') ADVANCE(1519); END_STATE(); - case 1329: + case 1520: ACCEPT_TOKEN(aux_sym_temp_table_tuning_token1); END_STATE(); - case 1330: - ACCEPT_TOKEN(aux_sym_field_option_token1); - END_STATE(); - case 1331: + case 1521: ACCEPT_TOKEN(aux_sym_field_definition_token1); END_STATE(); - case 1332: + case 1522: ACCEPT_TOKEN(aux_sym_index_tuning_token2); END_STATE(); - case 1333: + case 1523: ACCEPT_TOKEN(aux_sym_index_tuning_token3); END_STATE(); - case 1334: + case 1524: ACCEPT_TOKEN(aux_sym_index_tuning_token4); END_STATE(); - case 1335: + case 1525: ACCEPT_TOKEN(aux_sym_index_definition_token1); END_STATE(); - case 1336: - ACCEPT_TOKEN(aux_sym_widget_field_token1); - END_STATE(); - case 1337: - ACCEPT_TOKEN(aux_sym_widget_field_token1); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(296); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(590); - END_STATE(); - case 1338: - ACCEPT_TOKEN(aux_sym_widget_field_token1); - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(861); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(1135); - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(1147); - END_STATE(); - case 1339: - ACCEPT_TOKEN(aux_sym_widget_field_token1); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(590); - END_STATE(); - case 1340: + case 1526: ACCEPT_TOKEN(aux_sym_on_statement_token1); END_STATE(); default: @@ -16409,698 +18418,644 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { case 32: if (lookahead == 'C' || lookahead == 'c') ADVANCE(60); - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(61); if (lookahead == 'S' || - lookahead == 's') ADVANCE(62); + lookahead == 's') ADVANCE(61); END_STATE(); case 33: if (lookahead == 'L' || - lookahead == 'l') ADVANCE(63); + lookahead == 'l') ADVANCE(62); END_STATE(); case 34: if (lookahead == 'N' || - lookahead == 'n') ADVANCE(64); + lookahead == 'n') ADVANCE(63); END_STATE(); case 35: if (lookahead == 'N' || - lookahead == 'n') ADVANCE(65); + lookahead == 'n') ADVANCE(64); END_STATE(); case 36: ACCEPT_TOKEN(aux_sym_if_statement_token1); END_STATE(); case 37: + ACCEPT_TOKEN(aux_sym_widget_field_token1); if (lookahead == 'T' || - lookahead == 't') ADVANCE(66); + lookahead == 't') ADVANCE(65); END_STATE(); case 38: ACCEPT_TOKEN(aux_sym_index_tuning_token1); END_STATE(); case 39: if (lookahead == 'C' || - lookahead == 'c') ADVANCE(67); + lookahead == 'c') ADVANCE(66); if (lookahead == 'G' || - lookahead == 'g') ADVANCE(68); + lookahead == 'g') ADVANCE(67); if (lookahead == 'N' || - lookahead == 'n') ADVANCE(69); + lookahead == 'n') ADVANCE(68); END_STATE(); case 40: if (lookahead == 'M' || - lookahead == 'm') ADVANCE(70); + lookahead == 'm') ADVANCE(69); END_STATE(); case 41: ACCEPT_TOKEN(aux_sym_boolean_literal_token4); if (lookahead == 'T' || - lookahead == 't') ADVANCE(71); + lookahead == 't') ADVANCE(70); END_STATE(); case 42: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(72); + lookahead == 'e') ADVANCE(71); END_STATE(); case 43: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(73); if (lookahead == 'U' || - lookahead == 'u') ADVANCE(74); + lookahead == 'u') ADVANCE(72); END_STATE(); case 44: if (lookahead == 'S' || - lookahead == 's') ADVANCE(75); + lookahead == 's') ADVANCE(73); END_STATE(); case 45: - if (lookahead == 'C') ADVANCE(76); + if (lookahead == 'C') ADVANCE(74); END_STATE(); case 46: - if (lookahead == 'T') ADVANCE(77); + if (lookahead == 'T') ADVANCE(75); END_STATE(); case 47: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(78); + lookahead == 'i') ADVANCE(76); END_STATE(); case 48: - ACCEPT_TOKEN(aux_sym_primitive_type_token13); + ACCEPT_TOKEN(aux_sym_primitive_type_token14); END_STATE(); case 49: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(79); + lookahead == 'i') ADVANCE(77); END_STATE(); case 50: if (lookahead == 'U' || - lookahead == 'u') ADVANCE(80); + lookahead == 'u') ADVANCE(78); END_STATE(); case 51: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(81); + lookahead == 'i') ADVANCE(79); END_STATE(); case 52: ACCEPT_TOKEN(aux_sym_sort_order_token4); if (lookahead == 'E' || - lookahead == 'e') ADVANCE(82); + lookahead == 'e') ADVANCE(80); END_STATE(); case 53: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(83); + lookahead == 'i') ADVANCE(81); END_STATE(); case 54: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(84); + lookahead == 'i') ADVANCE(82); END_STATE(); case 55: - if (lookahead == '-') ADVANCE(85); + if (lookahead == '-') ADVANCE(83); END_STATE(); case 56: if (lookahead == 'R' || - lookahead == 'r') ADVANCE(86); + lookahead == 'r') ADVANCE(84); END_STATE(); case 57: - if (lookahead == '-') ADVANCE(87); + if (lookahead == '-') ADVANCE(85); END_STATE(); case 58: if (lookahead == 'R' || - lookahead == 'r') ADVANCE(88); + lookahead == 'r') ADVANCE(86); END_STATE(); case 59: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(89); + lookahead == 'e') ADVANCE(87); END_STATE(); case 60: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(90); + lookahead == 'i') ADVANCE(88); END_STATE(); case 61: - ACCEPT_TOKEN(aux_sym_variable_definition_token2); - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(91); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(89); END_STATE(); case 62: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(92); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(90); END_STATE(); case 63: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(93); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(91); END_STATE(); case 64: if (lookahead == 'D' || - lookahead == 'd') ADVANCE(94); + lookahead == 'd') ADVANCE(92); END_STATE(); case 65: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(95); + ACCEPT_TOKEN(aux_sym_primitive_type_token4); + if (lookahead == '6') ADVANCE(93); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(94); END_STATE(); case 66: - ACCEPT_TOKEN(aux_sym_primitive_type_token3); - if (lookahead == '6') ADVANCE(96); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(97); + if (lookahead == 'K' || + lookahead == 'k') ADVANCE(95); END_STATE(); case 67: - if (lookahead == 'K' || - lookahead == 'k') ADVANCE(98); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(96); END_STATE(); case 68: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(99); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(97); END_STATE(); case 69: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(100); + if (lookahead == 'P' || + lookahead == 'p') ADVANCE(98); END_STATE(); case 70: - if (lookahead == 'P' || - lookahead == 'p') ADVANCE(101); + ACCEPT_TOKEN(aux_sym_unary_expression_token2); END_STATE(); case 71: - ACCEPT_TOKEN(aux_sym_unary_expression_token2); + if (lookahead == 'V' || + lookahead == 'v') ADVANCE(99); END_STATE(); case 72: - if (lookahead == 'V' || - lookahead == 'v') ADVANCE(102); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(100); END_STATE(); case 73: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(103); + ACCEPT_TOKEN(aux_sym_boolean_literal_token3); END_STATE(); case 74: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(104); + if (lookahead == 'K') ADVANCE(101); END_STATE(); case 75: - ACCEPT_TOKEN(aux_sym_boolean_literal_token3); + if (lookahead == 'I') ADVANCE(102); END_STATE(); case 76: - if (lookahead == 'K') ADVANCE(105); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(103); END_STATE(); case 77: - if (lookahead == 'I') ADVANCE(106); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(104); END_STATE(); case 78: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(107); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(105); END_STATE(); case 79: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(108); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(106); END_STATE(); case 80: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(109); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(107); END_STATE(); case 81: if (lookahead == 'G' || - lookahead == 'g') ADVANCE(110); + lookahead == 'g') ADVANCE(108); END_STATE(); case 82: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(111); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(109); END_STATE(); case 83: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(112); + if (lookahead == 'F' || + lookahead == 'f') ADVANCE(110); END_STATE(); case 84: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(113); + ACCEPT_TOKEN(aux_sym_primitive_type_token6); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(111); END_STATE(); case 85: - if (lookahead == 'F' || - lookahead == 'f') ADVANCE(114); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(112); END_STATE(); case 86: - ACCEPT_TOKEN(aux_sym_primitive_type_token5); - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(115); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(113); END_STATE(); case 87: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(116); + ACCEPT_TOKEN(aux_sym_primitive_type_token8); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(114); END_STATE(); case 88: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(117); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(115); END_STATE(); case 89: - ACCEPT_TOKEN(aux_sym_primitive_type_token7); - if (lookahead == 'T' || - lookahead == 't') ADVANCE(118); + ACCEPT_TOKEN(aux_sym_sort_order_token3); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(116); END_STATE(); case 90: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(119); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(117); END_STATE(); case 91: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(120); + ACCEPT_TOKEN(aux_sym_find_statement_token1); END_STATE(); case 92: - ACCEPT_TOKEN(aux_sym_sort_order_token3); - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(121); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(118); END_STATE(); case 93: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(122); + if (lookahead == '4') ADVANCE(119); END_STATE(); case 94: - ACCEPT_TOKEN(aux_sym_find_statement_token1); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(120); END_STATE(); case 95: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(123); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(121); END_STATE(); case 96: - if (lookahead == '4') ADVANCE(124); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(122); END_STATE(); case 97: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(125); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(123); END_STATE(); case 98: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(126); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(124); END_STATE(); case 99: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(127); + ACCEPT_TOKEN(aux_sym__find_type_token1); END_STATE(); case 100: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(128); + ACCEPT_TOKEN(aux_sym_boolean_literal_token1); END_STATE(); case 101: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(129); + if (lookahead == '-') ADVANCE(125); END_STATE(); case 102: - ACCEPT_TOKEN(aux_sym__find_type_token1); + if (lookahead == 'N') ADVANCE(126); END_STATE(); case 103: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(130); + ACCEPT_TOKEN(aux_sym_primitive_type_token16); END_STATE(); case 104: - ACCEPT_TOKEN(aux_sym_boolean_literal_token1); + ACCEPT_TOKEN(aux_sym_primitive_type_token15); END_STATE(); case 105: - if (lookahead == '-') ADVANCE(131); + ACCEPT_TOKEN(aux_sym_accumulate_expression_token1); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(127); END_STATE(); case 106: - if (lookahead == 'N') ADVANCE(132); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(128); END_STATE(); case 107: - ACCEPT_TOKEN(aux_sym_primitive_type_token15); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(129); END_STATE(); case 108: - ACCEPT_TOKEN(aux_sym_primitive_type_token14); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(130); END_STATE(); case 109: - ACCEPT_TOKEN(aux_sym_accumulate_expression_token1); - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(133); + ACCEPT_TOKEN(aux_sym_available_expression_token1); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(131); END_STATE(); case 110: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(134); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(132); END_STATE(); case 111: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(135); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(133); END_STATE(); case 112: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(136); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(134); END_STATE(); case 113: - ACCEPT_TOKEN(aux_sym_available_expression_token1); - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(137); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(135); END_STATE(); case 114: if (lookahead == 'I' || - lookahead == 'i') ADVANCE(138); + lookahead == 'i') ADVANCE(136); END_STATE(); case 115: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(139); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(137); END_STATE(); case 116: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(140); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(138); END_STATE(); case 117: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(141); + ACCEPT_TOKEN(aux_sym_boolean_literal_token2); END_STATE(); case 118: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(142); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(139); END_STATE(); case 119: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(143); + ACCEPT_TOKEN(aux_sym_primitive_type_token11); END_STATE(); case 120: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(144); + lookahead == 'e') ADVANCE(140); END_STATE(); case 121: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(145); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(141); END_STATE(); case 122: - ACCEPT_TOKEN(aux_sym_boolean_literal_token2); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(142); END_STATE(); case 123: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(146); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(143); END_STATE(); case 124: - ACCEPT_TOKEN(aux_sym_primitive_type_token10); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(144); END_STATE(); case 125: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(147); + if (lookahead == 'L') ADVANCE(145); END_STATE(); case 126: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(148); + if (lookahead == 'E') ADVANCE(146); END_STATE(); case 127: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(149); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(147); END_STATE(); case 128: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(150); + if (lookahead == 'O' || + lookahead == 'o') ADVANCE(148); END_STATE(); case 129: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(151); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(149); END_STATE(); case 130: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(152); + ACCEPT_TOKEN(aux_sym_assign_statement_token1); END_STATE(); case 131: - if (lookahead == 'L') ADVANCE(153); + if (lookahead == 'B' || + lookahead == 'b') ADVANCE(150); END_STATE(); case 132: - if (lookahead == 'E') ADVANCE(154); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(151); END_STATE(); case 133: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(155); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(152); END_STATE(); case 134: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(156); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(153); END_STATE(); case 135: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(157); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(154); END_STATE(); case 136: - ACCEPT_TOKEN(aux_sym_assign_statement_token1); + if (lookahead == 'M' || + lookahead == 'm') ADVANCE(155); END_STATE(); case 137: - if (lookahead == 'B' || - lookahead == 'b') ADVANCE(158); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(156); END_STATE(); case 138: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(159); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(157); END_STATE(); case 139: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(160); + ACCEPT_TOKEN(aux_sym_primitive_type_token17); END_STATE(); case 140: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(161); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(158); END_STATE(); case 141: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(162); + ACCEPT_TOKEN(aux_sym_locked_expression_token1); END_STATE(); case 142: - if (lookahead == 'M' || - lookahead == 'm') ADVANCE(163); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(159); END_STATE(); case 143: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(164); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(160); END_STATE(); case 144: - ACCEPT_TOKEN(aux_sym_variable_definition_token1); + ACCEPT_TOKEN(aux_sym_primitive_type_token13); END_STATE(); case 145: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(165); + if (lookahead == 'E') ADVANCE(161); END_STATE(); case 146: - ACCEPT_TOKEN(aux_sym_primitive_type_token16); + if (lookahead == '-') ADVANCE(162); END_STATE(); case 147: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(166); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(163); END_STATE(); case 148: - ACCEPT_TOKEN(aux_sym_locked_expression_token1); + if (lookahead == 'U' || + lookahead == 'u') ADVANCE(164); END_STATE(); case 149: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(167); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(165); END_STATE(); case 150: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(168); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(166); END_STATE(); case 151: - ACCEPT_TOKEN(aux_sym_primitive_type_token12); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(167); END_STATE(); case 152: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(169); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(168); END_STATE(); case 153: - if (lookahead == 'E') ADVANCE(170); + if (lookahead == 'D' || + lookahead == 'd') ADVANCE(169); END_STATE(); case 154: - if (lookahead == '-') ADVANCE(171); + ACCEPT_TOKEN(aux_sym__find_type_token2); + if (lookahead == '-') ADVANCE(170); END_STATE(); case 155: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(172); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(171); END_STATE(); case 156: - if (lookahead == 'U' || - lookahead == 'u') ADVANCE(173); + ACCEPT_TOKEN(aux_sym_primitive_type_token7); END_STATE(); case 157: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(174); + if (lookahead == 'I' || + lookahead == 'i') ADVANCE(172); END_STATE(); case 158: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(175); + ACCEPT_TOKEN(aux_sym_primitive_type_token3); END_STATE(); case 159: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(176); + ACCEPT_TOKEN(aux_sym_primitive_type_token2); END_STATE(); case 160: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(177); + if (lookahead == 'R' || + lookahead == 'r') ADVANCE(173); END_STATE(); case 161: - if (lookahead == 'D' || - lookahead == 'd') ADVANCE(178); + if (lookahead == 'V') ADVANCE(174); END_STATE(); case 162: - ACCEPT_TOKEN(aux_sym__find_type_token2); - if (lookahead == '-') ADVANCE(179); + if (lookahead == 'L') ADVANCE(175); END_STATE(); case 163: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(180); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(176); END_STATE(); case 164: - ACCEPT_TOKEN(aux_sym_primitive_type_token6); + if (lookahead == 'S' || + lookahead == 's') ADVANCE(177); END_STATE(); case 165: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(181); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(178); END_STATE(); case 166: - ACCEPT_TOKEN(aux_sym_primitive_type_token2); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(179); END_STATE(); case 167: - ACCEPT_TOKEN(aux_sym_primitive_type_token1); + ACCEPT_TOKEN(aux_sym_can_find_expression_token1); END_STATE(); case 168: if (lookahead == 'R' || - lookahead == 'r') ADVANCE(182); + lookahead == 'r') ADVANCE(180); END_STATE(); case 169: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(183); + if (lookahead == 'L' || + lookahead == 'l') ADVANCE(181); END_STATE(); case 170: - if (lookahead == 'V') ADVANCE(184); + if (lookahead == 'C' || + lookahead == 'c') ADVANCE(182); END_STATE(); case 171: - if (lookahead == 'L') ADVANCE(185); + ACCEPT_TOKEN(aux_sym_primitive_type_token9); + if (lookahead == '-') ADVANCE(183); END_STATE(); case 172: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(186); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(184); END_STATE(); case 173: - if (lookahead == 'S' || - lookahead == 's') ADVANCE(187); + ACCEPT_TOKEN(aux_sym_primitive_type_token12); END_STATE(); case 174: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(188); + if (lookahead == 'E') ADVANCE(185); END_STATE(); case 175: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(189); + if (lookahead == 'E') ADVANCE(186); END_STATE(); case 176: - ACCEPT_TOKEN(aux_sym_can_find_expression_token1); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(187); END_STATE(); case 177: - if (lookahead == 'R' || - lookahead == 'r') ADVANCE(190); + ACCEPT_TOKEN(aux_sym_ambiguous_expression_token1); END_STATE(); case 178: - if (lookahead == 'L' || - lookahead == 'l') ADVANCE(191); + ACCEPT_TOKEN(aux_sym_sort_order_token1); END_STATE(); case 179: - if (lookahead == 'C' || - lookahead == 'c') ADVANCE(192); + ACCEPT_TOKEN(aux_sym_available_expression_token2); END_STATE(); case 180: - ACCEPT_TOKEN(aux_sym_primitive_type_token8); - if (lookahead == '-') ADVANCE(193); + ACCEPT_TOKEN(aux_sym_primitive_type_token5); END_STATE(); case 181: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(194); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(188); END_STATE(); case 182: - ACCEPT_TOKEN(aux_sym_primitive_type_token11); + if (lookahead == 'H' || + lookahead == 'h') ADVANCE(189); END_STATE(); case 183: - if (lookahead == 'I' || - lookahead == 'i') ADVANCE(195); + if (lookahead == 'T' || + lookahead == 't') ADVANCE(190); END_STATE(); case 184: - if (lookahead == 'E') ADVANCE(196); + if (lookahead == 'G' || + lookahead == 'g') ADVANCE(191); END_STATE(); case 185: - if (lookahead == 'E') ADVANCE(197); + if (lookahead == 'L') ADVANCE(192); END_STATE(); case 186: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(198); + if (lookahead == 'V') ADVANCE(193); END_STATE(); case 187: - ACCEPT_TOKEN(aux_sym_ambiguous_expression_token1); + ACCEPT_TOKEN(aux_sym_accumulate_statement_token1); END_STATE(); case 188: - ACCEPT_TOKEN(aux_sym_sort_order_token1); + ACCEPT_TOKEN(aux_sym_primitive_type_token18); END_STATE(); case 189: - ACCEPT_TOKEN(aux_sym_available_expression_token2); + if (lookahead == 'A' || + lookahead == 'a') ADVANCE(194); END_STATE(); case 190: - ACCEPT_TOKEN(aux_sym_primitive_type_token4); + if (lookahead == 'Z' || + lookahead == 'z') ADVANCE(195); END_STATE(); case 191: - if (lookahead == 'E' || - lookahead == 'e') ADVANCE(199); + ACCEPT_TOKEN(aux_sym_sort_order_token2); END_STATE(); case 192: - if (lookahead == 'H' || - lookahead == 'h') ADVANCE(200); + ACCEPT_TOKEN(anon_sym_BLOCK_DASHLEVEL); END_STATE(); case 193: - if (lookahead == 'T' || - lookahead == 't') ADVANCE(201); + if (lookahead == 'E') ADVANCE(196); END_STATE(); case 194: - if (lookahead == 'G' || - lookahead == 'g') ADVANCE(202); + if (lookahead == 'N' || + lookahead == 'n') ADVANCE(197); END_STATE(); case 195: - if (lookahead == 'O' || - lookahead == 'o') ADVANCE(203); + ACCEPT_TOKEN(aux_sym_primitive_type_token10); END_STATE(); case 196: - if (lookahead == 'L') ADVANCE(204); + if (lookahead == 'L') ADVANCE(198); END_STATE(); case 197: - if (lookahead == 'V') ADVANCE(205); - END_STATE(); - case 198: - ACCEPT_TOKEN(aux_sym_accumulate_statement_token1); - END_STATE(); - case 199: - ACCEPT_TOKEN(aux_sym_primitive_type_token17); - END_STATE(); - case 200: - if (lookahead == 'A' || - lookahead == 'a') ADVANCE(206); - END_STATE(); - case 201: - if (lookahead == 'Z' || - lookahead == 'z') ADVANCE(207); - END_STATE(); - case 202: - ACCEPT_TOKEN(aux_sym_sort_order_token2); - END_STATE(); - case 203: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(208); - END_STATE(); - case 204: - ACCEPT_TOKEN(anon_sym_BLOCK_DASHLEVEL); - END_STATE(); - case 205: - if (lookahead == 'E') ADVANCE(209); - END_STATE(); - case 206: - if (lookahead == 'N' || - lookahead == 'n') ADVANCE(210); - END_STATE(); - case 207: - ACCEPT_TOKEN(aux_sym_primitive_type_token9); - END_STATE(); - case 208: - ACCEPT_TOKEN(aux_sym_transaction_statement_token1); - END_STATE(); - case 209: - if (lookahead == 'L') ADVANCE(211); - END_STATE(); - case 210: if (lookahead == 'G' || - lookahead == 'g') ADVANCE(212); + lookahead == 'g') ADVANCE(199); END_STATE(); - case 211: + case 198: ACCEPT_TOKEN(anon_sym_ROUTINE_DASHLEVEL); END_STATE(); - case 212: + case 199: if (lookahead == 'E' || - lookahead == 'e') ADVANCE(213); + lookahead == 'e') ADVANCE(200); END_STATE(); - case 213: + case 200: if (lookahead == 'D' || - lookahead == 'd') ADVANCE(214); + lookahead == 'd') ADVANCE(201); END_STATE(); - case 214: + case 201: ACCEPT_TOKEN(aux_sym_current_changed_expression_token1); END_STATE(); default: @@ -17110,399 +19065,399 @@ static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { static const TSLexMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0, .external_lex_state = 1}, - [1] = {.lex_state = 644}, - [2] = {.lex_state = 92}, - [3] = {.lex_state = 51}, - [4] = {.lex_state = 92}, - [5] = {.lex_state = 92}, - [6] = {.lex_state = 92}, - [7] = {.lex_state = 92}, + [1] = {.lex_state = 736}, + [2] = {.lex_state = 734, .external_lex_state = 1}, + [3] = {.lex_state = 734, .external_lex_state = 1}, + [4] = {.lex_state = 99}, + [5] = {.lex_state = 99}, + [6] = {.lex_state = 99}, + [7] = {.lex_state = 99}, [8] = {.lex_state = 51}, - [9] = {.lex_state = 92}, - [10] = {.lex_state = 92}, - [11] = {.lex_state = 92}, - [12] = {.lex_state = 92}, - [13] = {.lex_state = 92}, - [14] = {.lex_state = 92}, - [15] = {.lex_state = 92}, - [16] = {.lex_state = 92}, - [17] = {.lex_state = 92}, - [18] = {.lex_state = 52, .external_lex_state = 1}, - [19] = {.lex_state = 92}, - [20] = {.lex_state = 92}, - [21] = {.lex_state = 92}, - [22] = {.lex_state = 92}, - [23] = {.lex_state = 92}, - [24] = {.lex_state = 92}, - [25] = {.lex_state = 92}, - [26] = {.lex_state = 92}, - [27] = {.lex_state = 92}, - [28] = {.lex_state = 92}, - [29] = {.lex_state = 92}, - [30] = {.lex_state = 92}, - [31] = {.lex_state = 92}, - [32] = {.lex_state = 92}, - [33] = {.lex_state = 92}, - [34] = {.lex_state = 92}, - [35] = {.lex_state = 92}, - [36] = {.lex_state = 92}, - [37] = {.lex_state = 92}, - [38] = {.lex_state = 92}, - [39] = {.lex_state = 92}, - [40] = {.lex_state = 52, .external_lex_state = 1}, - [41] = {.lex_state = 92}, - [42] = {.lex_state = 92}, - [43] = {.lex_state = 92}, - [44] = {.lex_state = 92}, - [45] = {.lex_state = 92}, - [46] = {.lex_state = 52, .external_lex_state = 1}, - [47] = {.lex_state = 92}, - [48] = {.lex_state = 92}, - [49] = {.lex_state = 92}, - [50] = {.lex_state = 92}, - [51] = {.lex_state = 92}, - [52] = {.lex_state = 92}, - [53] = {.lex_state = 52, .external_lex_state = 1}, - [54] = {.lex_state = 92}, - [55] = {.lex_state = 92}, - [56] = {.lex_state = 92}, - [57] = {.lex_state = 92}, - [58] = {.lex_state = 92}, - [59] = {.lex_state = 92}, - [60] = {.lex_state = 92}, - [61] = {.lex_state = 92}, - [62] = {.lex_state = 92}, - [63] = {.lex_state = 92}, - [64] = {.lex_state = 92}, - [65] = {.lex_state = 92}, - [66] = {.lex_state = 92}, - [67] = {.lex_state = 92}, - [68] = {.lex_state = 92}, - [69] = {.lex_state = 92}, - [70] = {.lex_state = 92}, - [71] = {.lex_state = 92}, - [72] = {.lex_state = 52, .external_lex_state = 1}, - [73] = {.lex_state = 92}, - [74] = {.lex_state = 92}, - [75] = {.lex_state = 92}, - [76] = {.lex_state = 92}, - [77] = {.lex_state = 92}, - [78] = {.lex_state = 92}, - [79] = {.lex_state = 92}, - [80] = {.lex_state = 92}, - [81] = {.lex_state = 92}, - [82] = {.lex_state = 92}, - [83] = {.lex_state = 92}, - [84] = {.lex_state = 92}, - [85] = {.lex_state = 92}, - [86] = {.lex_state = 92}, - [87] = {.lex_state = 92}, - [88] = {.lex_state = 92}, - [89] = {.lex_state = 92}, - [90] = {.lex_state = 92}, - [91] = {.lex_state = 92}, - [92] = {.lex_state = 92}, - [93] = {.lex_state = 92}, - [94] = {.lex_state = 92}, - [95] = {.lex_state = 92}, - [96] = {.lex_state = 92}, - [97] = {.lex_state = 52, .external_lex_state = 1}, - [98] = {.lex_state = 92}, - [99] = {.lex_state = 92}, - [100] = {.lex_state = 92}, - [101] = {.lex_state = 92}, - [102] = {.lex_state = 92}, - [103] = {.lex_state = 92}, - [104] = {.lex_state = 92}, - [105] = {.lex_state = 92}, - [106] = {.lex_state = 52, .external_lex_state = 1}, - [107] = {.lex_state = 92}, - [108] = {.lex_state = 92}, - [109] = {.lex_state = 92}, - [110] = {.lex_state = 92}, - [111] = {.lex_state = 92}, - [112] = {.lex_state = 92}, - [113] = {.lex_state = 92}, - [114] = {.lex_state = 92}, - [115] = {.lex_state = 92}, - [116] = {.lex_state = 92}, - [117] = {.lex_state = 92}, - [118] = {.lex_state = 92}, - [119] = {.lex_state = 92}, - [120] = {.lex_state = 92}, - [121] = {.lex_state = 92}, - [122] = {.lex_state = 92}, - [123] = {.lex_state = 92}, - [124] = {.lex_state = 92}, - [125] = {.lex_state = 92}, - [126] = {.lex_state = 92}, - [127] = {.lex_state = 92}, - [128] = {.lex_state = 92}, - [129] = {.lex_state = 92}, - [130] = {.lex_state = 92}, - [131] = {.lex_state = 92}, - [132] = {.lex_state = 92}, - [133] = {.lex_state = 92}, - [134] = {.lex_state = 92}, - [135] = {.lex_state = 92}, - [136] = {.lex_state = 92}, - [137] = {.lex_state = 92}, - [138] = {.lex_state = 92}, - [139] = {.lex_state = 92}, - [140] = {.lex_state = 92}, - [141] = {.lex_state = 92}, - [142] = {.lex_state = 92}, - [143] = {.lex_state = 92}, - [144] = {.lex_state = 92}, - [145] = {.lex_state = 92}, - [146] = {.lex_state = 92}, - [147] = {.lex_state = 92}, - [148] = {.lex_state = 92}, - [149] = {.lex_state = 92}, - [150] = {.lex_state = 52, .external_lex_state = 1}, - [151] = {.lex_state = 92}, - [152] = {.lex_state = 92}, - [153] = {.lex_state = 92}, - [154] = {.lex_state = 92}, - [155] = {.lex_state = 92}, - [156] = {.lex_state = 92}, - [157] = {.lex_state = 92}, - [158] = {.lex_state = 92}, - [159] = {.lex_state = 92}, - [160] = {.lex_state = 92}, - [161] = {.lex_state = 92}, - [162] = {.lex_state = 92}, - [163] = {.lex_state = 92}, - [164] = {.lex_state = 92}, - [165] = {.lex_state = 92}, - [166] = {.lex_state = 92}, - [167] = {.lex_state = 92}, - [168] = {.lex_state = 92}, - [169] = {.lex_state = 92}, - [170] = {.lex_state = 92}, - [171] = {.lex_state = 92}, - [172] = {.lex_state = 92}, - [173] = {.lex_state = 92}, - [174] = {.lex_state = 92}, - [175] = {.lex_state = 92}, - [176] = {.lex_state = 92}, - [177] = {.lex_state = 92}, - [178] = {.lex_state = 92}, - [179] = {.lex_state = 92}, - [180] = {.lex_state = 92}, - [181] = {.lex_state = 92}, - [182] = {.lex_state = 92}, - [183] = {.lex_state = 92}, - [184] = {.lex_state = 92}, - [185] = {.lex_state = 92}, - [186] = {.lex_state = 92}, - [187] = {.lex_state = 92}, - [188] = {.lex_state = 92}, - [189] = {.lex_state = 92}, - [190] = {.lex_state = 92}, - [191] = {.lex_state = 92}, - [192] = {.lex_state = 92}, - [193] = {.lex_state = 92}, - [194] = {.lex_state = 92}, - [195] = {.lex_state = 92}, - [196] = {.lex_state = 92}, - [197] = {.lex_state = 92}, - [198] = {.lex_state = 92}, - [199] = {.lex_state = 92}, - [200] = {.lex_state = 92}, - [201] = {.lex_state = 92}, - [202] = {.lex_state = 92}, - [203] = {.lex_state = 52, .external_lex_state = 1}, - [204] = {.lex_state = 92}, - [205] = {.lex_state = 92}, - [206] = {.lex_state = 92}, - [207] = {.lex_state = 92}, - [208] = {.lex_state = 92}, - [209] = {.lex_state = 92}, - [210] = {.lex_state = 92}, - [211] = {.lex_state = 92}, - [212] = {.lex_state = 92}, - [213] = {.lex_state = 52, .external_lex_state = 1}, - [214] = {.lex_state = 92}, - [215] = {.lex_state = 92}, - [216] = {.lex_state = 92}, - [217] = {.lex_state = 92}, - [218] = {.lex_state = 92}, - [219] = {.lex_state = 92}, - [220] = {.lex_state = 92}, - [221] = {.lex_state = 92}, - [222] = {.lex_state = 92}, - [223] = {.lex_state = 92}, - [224] = {.lex_state = 92}, - [225] = {.lex_state = 92}, - [226] = {.lex_state = 92}, - [227] = {.lex_state = 92}, - [228] = {.lex_state = 92}, - [229] = {.lex_state = 92}, - [230] = {.lex_state = 92}, - [231] = {.lex_state = 92}, - [232] = {.lex_state = 92}, - [233] = {.lex_state = 92}, - [234] = {.lex_state = 92}, - [235] = {.lex_state = 92}, - [236] = {.lex_state = 92}, - [237] = {.lex_state = 92}, - [238] = {.lex_state = 92}, - [239] = {.lex_state = 92}, - [240] = {.lex_state = 92}, - [241] = {.lex_state = 92}, - [242] = {.lex_state = 92}, - [243] = {.lex_state = 92}, - [244] = {.lex_state = 92}, - [245] = {.lex_state = 92}, - [246] = {.lex_state = 92}, - [247] = {.lex_state = 92}, - [248] = {.lex_state = 92}, - [249] = {.lex_state = 92}, - [250] = {.lex_state = 92}, - [251] = {.lex_state = 92}, - [252] = {.lex_state = 92}, - [253] = {.lex_state = 92}, - [254] = {.lex_state = 92}, - [255] = {.lex_state = 92}, - [256] = {.lex_state = 92}, - [257] = {.lex_state = 92}, - [258] = {.lex_state = 92}, - [259] = {.lex_state = 92}, - [260] = {.lex_state = 92}, - [261] = {.lex_state = 92}, - [262] = {.lex_state = 52}, - [263] = {.lex_state = 52}, - [264] = {.lex_state = 92}, - [265] = {.lex_state = 644}, - [266] = {.lex_state = 52}, - [267] = {.lex_state = 52}, - [268] = {.lex_state = 52}, - [269] = {.lex_state = 52}, - [270] = {.lex_state = 52}, - [271] = {.lex_state = 52}, - [272] = {.lex_state = 52}, - [273] = {.lex_state = 52}, - [274] = {.lex_state = 644}, - [275] = {.lex_state = 642, .external_lex_state = 1}, - [276] = {.lex_state = 642, .external_lex_state = 1}, - [277] = {.lex_state = 642, .external_lex_state = 1}, - [278] = {.lex_state = 642}, - [279] = {.lex_state = 642}, - [280] = {.lex_state = 642}, - [281] = {.lex_state = 642}, - [282] = {.lex_state = 642}, - [283] = {.lex_state = 42, .external_lex_state = 1}, - [284] = {.lex_state = 42}, - [285] = {.lex_state = 42}, - [286] = {.lex_state = 42, .external_lex_state = 1}, - [287] = {.lex_state = 42, .external_lex_state = 1}, - [288] = {.lex_state = 53}, - [289] = {.lex_state = 53}, - [290] = {.lex_state = 53}, - [291] = {.lex_state = 53}, - [292] = {.lex_state = 53}, - [293] = {.lex_state = 53}, - [294] = {.lex_state = 53}, - [295] = {.lex_state = 53}, - [296] = {.lex_state = 53}, - [297] = {.lex_state = 53}, - [298] = {.lex_state = 42}, - [299] = {.lex_state = 53}, - [300] = {.lex_state = 53}, - [301] = {.lex_state = 53}, - [302] = {.lex_state = 53}, - [303] = {.lex_state = 53}, - [304] = {.lex_state = 42}, - [305] = {.lex_state = 42}, - [306] = {.lex_state = 42}, - [307] = {.lex_state = 42}, - [308] = {.lex_state = 42}, - [309] = {.lex_state = 42}, - [310] = {.lex_state = 42}, - [311] = {.lex_state = 44, .external_lex_state = 1}, - [312] = {.lex_state = 42}, - [313] = {.lex_state = 42}, - [314] = {.lex_state = 44, .external_lex_state = 1}, - [315] = {.lex_state = 42}, - [316] = {.lex_state = 42}, - [317] = {.lex_state = 42}, - [318] = {.lex_state = 42}, - [319] = {.lex_state = 42}, - [320] = {.lex_state = 42}, - [321] = {.lex_state = 42}, - [322] = {.lex_state = 42}, - [323] = {.lex_state = 42}, - [324] = {.lex_state = 42}, - [325] = {.lex_state = 42}, - [326] = {.lex_state = 42}, - [327] = {.lex_state = 42}, - [328] = {.lex_state = 53}, - [329] = {.lex_state = 54}, - [330] = {.lex_state = 44}, - [331] = {.lex_state = 54}, - [332] = {.lex_state = 54}, - [333] = {.lex_state = 54}, - [334] = {.lex_state = 54}, + [9] = {.lex_state = 99}, + [10] = {.lex_state = 99}, + [11] = {.lex_state = 99}, + [12] = {.lex_state = 51}, + [13] = {.lex_state = 734, .external_lex_state = 1}, + [14] = {.lex_state = 99}, + [15] = {.lex_state = 99}, + [16] = {.lex_state = 99}, + [17] = {.lex_state = 99}, + [18] = {.lex_state = 99}, + [19] = {.lex_state = 99}, + [20] = {.lex_state = 99}, + [21] = {.lex_state = 99}, + [22] = {.lex_state = 99}, + [23] = {.lex_state = 99}, + [24] = {.lex_state = 99}, + [25] = {.lex_state = 99}, + [26] = {.lex_state = 99}, + [27] = {.lex_state = 99}, + [28] = {.lex_state = 99}, + [29] = {.lex_state = 99}, + [30] = {.lex_state = 99}, + [31] = {.lex_state = 99}, + [32] = {.lex_state = 99}, + [33] = {.lex_state = 99}, + [34] = {.lex_state = 99}, + [35] = {.lex_state = 99}, + [36] = {.lex_state = 99}, + [37] = {.lex_state = 99}, + [38] = {.lex_state = 99}, + [39] = {.lex_state = 99}, + [40] = {.lex_state = 99}, + [41] = {.lex_state = 99}, + [42] = {.lex_state = 99}, + [43] = {.lex_state = 99}, + [44] = {.lex_state = 99}, + [45] = {.lex_state = 99}, + [46] = {.lex_state = 99}, + [47] = {.lex_state = 99}, + [48] = {.lex_state = 99}, + [49] = {.lex_state = 99}, + [50] = {.lex_state = 99}, + [51] = {.lex_state = 99}, + [52] = {.lex_state = 99}, + [53] = {.lex_state = 99}, + [54] = {.lex_state = 99}, + [55] = {.lex_state = 99}, + [56] = {.lex_state = 99}, + [57] = {.lex_state = 99}, + [58] = {.lex_state = 99}, + [59] = {.lex_state = 52, .external_lex_state = 1}, + [60] = {.lex_state = 52, .external_lex_state = 1}, + [61] = {.lex_state = 99}, + [62] = {.lex_state = 99}, + [63] = {.lex_state = 99}, + [64] = {.lex_state = 99}, + [65] = {.lex_state = 99}, + [66] = {.lex_state = 99}, + [67] = {.lex_state = 99}, + [68] = {.lex_state = 99}, + [69] = {.lex_state = 99}, + [70] = {.lex_state = 99}, + [71] = {.lex_state = 52, .external_lex_state = 1}, + [72] = {.lex_state = 99}, + [73] = {.lex_state = 99}, + [74] = {.lex_state = 99}, + [75] = {.lex_state = 99}, + [76] = {.lex_state = 99}, + [77] = {.lex_state = 99}, + [78] = {.lex_state = 99}, + [79] = {.lex_state = 99}, + [80] = {.lex_state = 99}, + [81] = {.lex_state = 99}, + [82] = {.lex_state = 99}, + [83] = {.lex_state = 99}, + [84] = {.lex_state = 52, .external_lex_state = 1}, + [85] = {.lex_state = 99}, + [86] = {.lex_state = 99}, + [87] = {.lex_state = 99}, + [88] = {.lex_state = 99}, + [89] = {.lex_state = 99}, + [90] = {.lex_state = 99}, + [91] = {.lex_state = 99}, + [92] = {.lex_state = 99}, + [93] = {.lex_state = 99}, + [94] = {.lex_state = 99}, + [95] = {.lex_state = 99}, + [96] = {.lex_state = 99}, + [97] = {.lex_state = 99}, + [98] = {.lex_state = 99}, + [99] = {.lex_state = 99}, + [100] = {.lex_state = 99}, + [101] = {.lex_state = 99}, + [102] = {.lex_state = 99}, + [103] = {.lex_state = 99}, + [104] = {.lex_state = 99}, + [105] = {.lex_state = 99}, + [106] = {.lex_state = 99}, + [107] = {.lex_state = 99}, + [108] = {.lex_state = 99}, + [109] = {.lex_state = 99}, + [110] = {.lex_state = 99}, + [111] = {.lex_state = 99}, + [112] = {.lex_state = 99}, + [113] = {.lex_state = 99}, + [114] = {.lex_state = 52, .external_lex_state = 1}, + [115] = {.lex_state = 99}, + [116] = {.lex_state = 99}, + [117] = {.lex_state = 99}, + [118] = {.lex_state = 52, .external_lex_state = 1}, + [119] = {.lex_state = 99}, + [120] = {.lex_state = 99}, + [121] = {.lex_state = 99}, + [122] = {.lex_state = 99}, + [123] = {.lex_state = 99}, + [124] = {.lex_state = 99}, + [125] = {.lex_state = 99}, + [126] = {.lex_state = 99}, + [127] = {.lex_state = 99}, + [128] = {.lex_state = 99}, + [129] = {.lex_state = 99}, + [130] = {.lex_state = 99}, + [131] = {.lex_state = 99}, + [132] = {.lex_state = 99}, + [133] = {.lex_state = 99}, + [134] = {.lex_state = 99}, + [135] = {.lex_state = 99}, + [136] = {.lex_state = 99}, + [137] = {.lex_state = 99}, + [138] = {.lex_state = 99}, + [139] = {.lex_state = 99}, + [140] = {.lex_state = 99}, + [141] = {.lex_state = 99}, + [142] = {.lex_state = 99}, + [143] = {.lex_state = 99}, + [144] = {.lex_state = 99}, + [145] = {.lex_state = 99}, + [146] = {.lex_state = 99}, + [147] = {.lex_state = 99}, + [148] = {.lex_state = 99}, + [149] = {.lex_state = 99}, + [150] = {.lex_state = 99}, + [151] = {.lex_state = 99}, + [152] = {.lex_state = 99}, + [153] = {.lex_state = 99}, + [154] = {.lex_state = 52, .external_lex_state = 1}, + [155] = {.lex_state = 99}, + [156] = {.lex_state = 99}, + [157] = {.lex_state = 99}, + [158] = {.lex_state = 99}, + [159] = {.lex_state = 99}, + [160] = {.lex_state = 99}, + [161] = {.lex_state = 99}, + [162] = {.lex_state = 99}, + [163] = {.lex_state = 99}, + [164] = {.lex_state = 99}, + [165] = {.lex_state = 99}, + [166] = {.lex_state = 99}, + [167] = {.lex_state = 99}, + [168] = {.lex_state = 99}, + [169] = {.lex_state = 52, .external_lex_state = 1}, + [170] = {.lex_state = 99}, + [171] = {.lex_state = 99}, + [172] = {.lex_state = 52, .external_lex_state = 1}, + [173] = {.lex_state = 99}, + [174] = {.lex_state = 99}, + [175] = {.lex_state = 99}, + [176] = {.lex_state = 99}, + [177] = {.lex_state = 99}, + [178] = {.lex_state = 99}, + [179] = {.lex_state = 99}, + [180] = {.lex_state = 99}, + [181] = {.lex_state = 99}, + [182] = {.lex_state = 99}, + [183] = {.lex_state = 99}, + [184] = {.lex_state = 99}, + [185] = {.lex_state = 99}, + [186] = {.lex_state = 99}, + [187] = {.lex_state = 99}, + [188] = {.lex_state = 99}, + [189] = {.lex_state = 99}, + [190] = {.lex_state = 99}, + [191] = {.lex_state = 99}, + [192] = {.lex_state = 99}, + [193] = {.lex_state = 99}, + [194] = {.lex_state = 99}, + [195] = {.lex_state = 99}, + [196] = {.lex_state = 99}, + [197] = {.lex_state = 99}, + [198] = {.lex_state = 99}, + [199] = {.lex_state = 52, .external_lex_state = 1}, + [200] = {.lex_state = 99}, + [201] = {.lex_state = 99}, + [202] = {.lex_state = 99}, + [203] = {.lex_state = 99}, + [204] = {.lex_state = 99}, + [205] = {.lex_state = 99}, + [206] = {.lex_state = 99}, + [207] = {.lex_state = 99}, + [208] = {.lex_state = 99}, + [209] = {.lex_state = 99}, + [210] = {.lex_state = 99}, + [211] = {.lex_state = 99}, + [212] = {.lex_state = 52, .external_lex_state = 1}, + [213] = {.lex_state = 99}, + [214] = {.lex_state = 99}, + [215] = {.lex_state = 99}, + [216] = {.lex_state = 99}, + [217] = {.lex_state = 99}, + [218] = {.lex_state = 99}, + [219] = {.lex_state = 99}, + [220] = {.lex_state = 99}, + [221] = {.lex_state = 99}, + [222] = {.lex_state = 99}, + [223] = {.lex_state = 99}, + [224] = {.lex_state = 99}, + [225] = {.lex_state = 99}, + [226] = {.lex_state = 99}, + [227] = {.lex_state = 99}, + [228] = {.lex_state = 99}, + [229] = {.lex_state = 99}, + [230] = {.lex_state = 99}, + [231] = {.lex_state = 99}, + [232] = {.lex_state = 99}, + [233] = {.lex_state = 99}, + [234] = {.lex_state = 99}, + [235] = {.lex_state = 99}, + [236] = {.lex_state = 99}, + [237] = {.lex_state = 99}, + [238] = {.lex_state = 99}, + [239] = {.lex_state = 99}, + [240] = {.lex_state = 99}, + [241] = {.lex_state = 99}, + [242] = {.lex_state = 99}, + [243] = {.lex_state = 99}, + [244] = {.lex_state = 99}, + [245] = {.lex_state = 99}, + [246] = {.lex_state = 99}, + [247] = {.lex_state = 99}, + [248] = {.lex_state = 99}, + [249] = {.lex_state = 99}, + [250] = {.lex_state = 99}, + [251] = {.lex_state = 99}, + [252] = {.lex_state = 99}, + [253] = {.lex_state = 99}, + [254] = {.lex_state = 99}, + [255] = {.lex_state = 99}, + [256] = {.lex_state = 99}, + [257] = {.lex_state = 99}, + [258] = {.lex_state = 99}, + [259] = {.lex_state = 99}, + [260] = {.lex_state = 99}, + [261] = {.lex_state = 99}, + [262] = {.lex_state = 52, .external_lex_state = 1}, + [263] = {.lex_state = 99}, + [264] = {.lex_state = 99}, + [265] = {.lex_state = 99}, + [266] = {.lex_state = 99}, + [267] = {.lex_state = 99}, + [268] = {.lex_state = 99}, + [269] = {.lex_state = 99}, + [270] = {.lex_state = 99}, + [271] = {.lex_state = 99}, + [272] = {.lex_state = 99}, + [273] = {.lex_state = 99}, + [274] = {.lex_state = 99}, + [275] = {.lex_state = 99}, + [276] = {.lex_state = 99}, + [277] = {.lex_state = 99}, + [278] = {.lex_state = 52}, + [279] = {.lex_state = 52}, + [280] = {.lex_state = 52}, + [281] = {.lex_state = 736}, + [282] = {.lex_state = 736}, + [283] = {.lex_state = 52}, + [284] = {.lex_state = 52}, + [285] = {.lex_state = 52}, + [286] = {.lex_state = 99}, + [287] = {.lex_state = 52}, + [288] = {.lex_state = 52}, + [289] = {.lex_state = 52}, + [290] = {.lex_state = 99}, + [291] = {.lex_state = 52}, + [292] = {.lex_state = 52}, + [293] = {.lex_state = 52}, + [294] = {.lex_state = 44}, + [295] = {.lex_state = 44}, + [296] = {.lex_state = 44}, + [297] = {.lex_state = 44}, + [298] = {.lex_state = 44}, + [299] = {.lex_state = 44, .external_lex_state = 1}, + [300] = {.lex_state = 44}, + [301] = {.lex_state = 44}, + [302] = {.lex_state = 44}, + [303] = {.lex_state = 44}, + [304] = {.lex_state = 53}, + [305] = {.lex_state = 44}, + [306] = {.lex_state = 44}, + [307] = {.lex_state = 44}, + [308] = {.lex_state = 44}, + [309] = {.lex_state = 44}, + [310] = {.lex_state = 44}, + [311] = {.lex_state = 53}, + [312] = {.lex_state = 44}, + [313] = {.lex_state = 53}, + [314] = {.lex_state = 53}, + [315] = {.lex_state = 53}, + [316] = {.lex_state = 53}, + [317] = {.lex_state = 53}, + [318] = {.lex_state = 53}, + [319] = {.lex_state = 44}, + [320] = {.lex_state = 44}, + [321] = {.lex_state = 44}, + [322] = {.lex_state = 44}, + [323] = {.lex_state = 44}, + [324] = {.lex_state = 53}, + [325] = {.lex_state = 53}, + [326] = {.lex_state = 44}, + [327] = {.lex_state = 44}, + [328] = {.lex_state = 44}, + [329] = {.lex_state = 44}, + [330] = {.lex_state = 53}, + [331] = {.lex_state = 44}, + [332] = {.lex_state = 53}, + [333] = {.lex_state = 53}, + [334] = {.lex_state = 53}, [335] = {.lex_state = 44}, - [336] = {.lex_state = 44}, - [337] = {.lex_state = 32}, - [338] = {.lex_state = 32}, - [339] = {.lex_state = 32}, - [340] = {.lex_state = 32}, + [336] = {.lex_state = 53}, + [337] = {.lex_state = 53}, + [338] = {.lex_state = 44}, + [339] = {.lex_state = 44}, + [340] = {.lex_state = 53}, [341] = {.lex_state = 44}, - [342] = {.lex_state = 32}, - [343] = {.lex_state = 44}, - [344] = {.lex_state = 44}, - [345] = {.lex_state = 32, .external_lex_state = 1}, - [346] = {.lex_state = 32}, - [347] = {.lex_state = 32}, - [348] = {.lex_state = 32}, - [349] = {.lex_state = 32, .external_lex_state = 1}, - [350] = {.lex_state = 32}, - [351] = {.lex_state = 32}, - [352] = {.lex_state = 32}, - [353] = {.lex_state = 54}, - [354] = {.lex_state = 54}, - [355] = {.lex_state = 54}, - [356] = {.lex_state = 54}, - [357] = {.lex_state = 54}, - [358] = {.lex_state = 54}, - [359] = {.lex_state = 54}, - [360] = {.lex_state = 32, .external_lex_state = 1}, - [361] = {.lex_state = 54}, - [362] = {.lex_state = 54}, - [363] = {.lex_state = 32}, - [364] = {.lex_state = 32, .external_lex_state = 1}, - [365] = {.lex_state = 54}, - [366] = {.lex_state = 32, .external_lex_state = 1}, - [367] = {.lex_state = 54}, - [368] = {.lex_state = 32}, - [369] = {.lex_state = 32, .external_lex_state = 1}, - [370] = {.lex_state = 54}, + [342] = {.lex_state = 734, .external_lex_state = 1}, + [343] = {.lex_state = 734, .external_lex_state = 1}, + [344] = {.lex_state = 46, .external_lex_state = 1}, + [345] = {.lex_state = 46, .external_lex_state = 1}, + [346] = {.lex_state = 53}, + [347] = {.lex_state = 54}, + [348] = {.lex_state = 54}, + [349] = {.lex_state = 54}, + [350] = {.lex_state = 46}, + [351] = {.lex_state = 54}, + [352] = {.lex_state = 54}, + [353] = {.lex_state = 46}, + [354] = {.lex_state = 32}, + [355] = {.lex_state = 32}, + [356] = {.lex_state = 32}, + [357] = {.lex_state = 32}, + [358] = {.lex_state = 32}, + [359] = {.lex_state = 32}, + [360] = {.lex_state = 32}, + [361] = {.lex_state = 32}, + [362] = {.lex_state = 32}, + [363] = {.lex_state = 32, .external_lex_state = 1}, + [364] = {.lex_state = 32}, + [365] = {.lex_state = 32, .external_lex_state = 1}, + [366] = {.lex_state = 46}, + [367] = {.lex_state = 46}, + [368] = {.lex_state = 46}, + [369] = {.lex_state = 46}, + [370] = {.lex_state = 32}, [371] = {.lex_state = 54}, [372] = {.lex_state = 54}, [373] = {.lex_state = 54}, [374] = {.lex_state = 54}, [375] = {.lex_state = 54}, [376] = {.lex_state = 54}, - [377] = {.lex_state = 54}, - [378] = {.lex_state = 54}, + [377] = {.lex_state = 32, .external_lex_state = 1}, + [378] = {.lex_state = 32}, [379] = {.lex_state = 54}, - [380] = {.lex_state = 54}, + [380] = {.lex_state = 32, .external_lex_state = 1}, [381] = {.lex_state = 54}, [382] = {.lex_state = 54}, - [383] = {.lex_state = 54}, - [384] = {.lex_state = 54}, - [385] = {.lex_state = 54}, + [383] = {.lex_state = 32, .external_lex_state = 1}, + [384] = {.lex_state = 32}, + [385] = {.lex_state = 32, .external_lex_state = 1}, [386] = {.lex_state = 54}, [387] = {.lex_state = 54}, [388] = {.lex_state = 54}, - [389] = {.lex_state = 54}, + [389] = {.lex_state = 32}, [390] = {.lex_state = 54}, [391] = {.lex_state = 54}, [392] = {.lex_state = 54}, - [393] = {.lex_state = 34}, + [393] = {.lex_state = 54}, [394] = {.lex_state = 54}, [395] = {.lex_state = 54}, [396] = {.lex_state = 54}, @@ -17512,16 +19467,16 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [400] = {.lex_state = 54}, [401] = {.lex_state = 54}, [402] = {.lex_state = 54}, - [403] = {.lex_state = 32}, + [403] = {.lex_state = 54}, [404] = {.lex_state = 54}, [405] = {.lex_state = 54}, [406] = {.lex_state = 54}, [407] = {.lex_state = 54}, [408] = {.lex_state = 54}, [409] = {.lex_state = 54}, - [410] = {.lex_state = 32}, + [410] = {.lex_state = 54}, [411] = {.lex_state = 54}, - [412] = {.lex_state = 32}, + [412] = {.lex_state = 54}, [413] = {.lex_state = 54}, [414] = {.lex_state = 54}, [415] = {.lex_state = 54}, @@ -17536,7 +19491,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [424] = {.lex_state = 54}, [425] = {.lex_state = 54}, [426] = {.lex_state = 54}, - [427] = {.lex_state = 54}, + [427] = {.lex_state = 32}, [428] = {.lex_state = 54}, [429] = {.lex_state = 54}, [430] = {.lex_state = 54}, @@ -17566,7 +19521,7 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [454] = {.lex_state = 54}, [455] = {.lex_state = 54}, [456] = {.lex_state = 54}, - [457] = {.lex_state = 32, .external_lex_state = 1}, + [457] = {.lex_state = 54}, [458] = {.lex_state = 54}, [459] = {.lex_state = 54}, [460] = {.lex_state = 54}, @@ -17594,14 +19549,14 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [482] = {.lex_state = 54}, [483] = {.lex_state = 54}, [484] = {.lex_state = 54}, - [485] = {.lex_state = 32}, + [485] = {.lex_state = 34}, [486] = {.lex_state = 54}, [487] = {.lex_state = 54}, [488] = {.lex_state = 54}, [489] = {.lex_state = 54}, [490] = {.lex_state = 54}, [491] = {.lex_state = 54}, - [492] = {.lex_state = 32, .external_lex_state = 1}, + [492] = {.lex_state = 54}, [493] = {.lex_state = 54}, [494] = {.lex_state = 54}, [495] = {.lex_state = 54}, @@ -17621,2812 +19576,3308 @@ static const TSLexMode ts_lex_modes[STATE_COUNT] = { [509] = {.lex_state = 54}, [510] = {.lex_state = 54}, [511] = {.lex_state = 54}, - [512] = {.lex_state = 54}, + [512] = {.lex_state = 48}, [513] = {.lex_state = 54}, [514] = {.lex_state = 54}, - [515] = {.lex_state = 32}, - [516] = {.lex_state = 32}, - [517] = {.lex_state = 32}, - [518] = {.lex_state = 32}, - [519] = {.lex_state = 32}, - [520] = {.lex_state = 32}, - [521] = {.lex_state = 32}, - [522] = {.lex_state = 32}, - [523] = {.lex_state = 32}, - [524] = {.lex_state = 32}, + [515] = {.lex_state = 54}, + [516] = {.lex_state = 48}, + [517] = {.lex_state = 54}, + [518] = {.lex_state = 54}, + [519] = {.lex_state = 54}, + [520] = {.lex_state = 54}, + [521] = {.lex_state = 54}, + [522] = {.lex_state = 54}, + [523] = {.lex_state = 54}, + [524] = {.lex_state = 54}, [525] = {.lex_state = 32}, [526] = {.lex_state = 32}, - [527] = {.lex_state = 32}, - [528] = {.lex_state = 32}, - [529] = {.lex_state = 32}, - [530] = {.lex_state = 32}, - [531] = {.lex_state = 32}, - [532] = {.lex_state = 32}, - [533] = {.lex_state = 32}, - [534] = {.lex_state = 32}, - [535] = {.lex_state = 32}, - [536] = {.lex_state = 32}, - [537] = {.lex_state = 32}, - [538] = {.lex_state = 32}, - [539] = {.lex_state = 32}, - [540] = {.lex_state = 32}, - [541] = {.lex_state = 32}, - [542] = {.lex_state = 32}, - [543] = {.lex_state = 42}, - [544] = {.lex_state = 42}, - [545] = {.lex_state = 42}, - [546] = {.lex_state = 42}, - [547] = {.lex_state = 42}, - [548] = {.lex_state = 42}, - [549] = {.lex_state = 42}, - [550] = {.lex_state = 42}, - [551] = {.lex_state = 42}, - [552] = {.lex_state = 42}, - [553] = {.lex_state = 46}, - [554] = {.lex_state = 46}, - [555] = {.lex_state = 642}, - [556] = {.lex_state = 642}, - [557] = {.lex_state = 642}, - [558] = {.lex_state = 642}, - [559] = {.lex_state = 642}, - [560] = {.lex_state = 642}, - [561] = {.lex_state = 642}, - [562] = {.lex_state = 642}, - [563] = {.lex_state = 642}, - [564] = {.lex_state = 642}, - [565] = {.lex_state = 642}, - [566] = {.lex_state = 642}, - [567] = {.lex_state = 642, .external_lex_state = 1}, - [568] = {.lex_state = 642, .external_lex_state = 1}, - [569] = {.lex_state = 642}, - [570] = {.lex_state = 642}, - [571] = {.lex_state = 642}, - [572] = {.lex_state = 642}, - [573] = {.lex_state = 642}, - [574] = {.lex_state = 642}, - [575] = {.lex_state = 642}, - [576] = {.lex_state = 642}, - [577] = {.lex_state = 642}, - [578] = {.lex_state = 642}, - [579] = {.lex_state = 642}, - [580] = {.lex_state = 642}, - [581] = {.lex_state = 642}, - [582] = {.lex_state = 642}, - [583] = {.lex_state = 642}, - [584] = {.lex_state = 642}, - [585] = {.lex_state = 36, .external_lex_state = 1}, - [586] = {.lex_state = 642}, - [587] = {.lex_state = 642}, - [588] = {.lex_state = 642}, - [589] = {.lex_state = 642}, - [590] = {.lex_state = 642}, - [591] = {.lex_state = 36, .external_lex_state = 1}, - [592] = {.lex_state = 642}, - [593] = {.lex_state = 36, .external_lex_state = 1}, - [594] = {.lex_state = 36, .external_lex_state = 1}, - [595] = {.lex_state = 36, .external_lex_state = 1}, - [596] = {.lex_state = 642}, - [597] = {.lex_state = 36}, - [598] = {.lex_state = 36}, - [599] = {.lex_state = 36}, - [600] = {.lex_state = 36}, - [601] = {.lex_state = 36}, - [602] = {.lex_state = 642}, - [603] = {.lex_state = 36}, - [604] = {.lex_state = 36}, - [605] = {.lex_state = 642}, - [606] = {.lex_state = 36}, - [607] = {.lex_state = 36}, - [608] = {.lex_state = 36}, - [609] = {.lex_state = 36}, - [610] = {.lex_state = 48}, - [611] = {.lex_state = 48}, - [612] = {.lex_state = 642}, - [613] = {.lex_state = 48}, - [614] = {.lex_state = 48}, - [615] = {.lex_state = 48}, - [616] = {.lex_state = 48}, - [617] = {.lex_state = 36}, - [618] = {.lex_state = 36, .external_lex_state = 1}, - [619] = {.lex_state = 36, .external_lex_state = 1}, - [620] = {.lex_state = 36}, + [527] = {.lex_state = 54}, + [528] = {.lex_state = 54}, + [529] = {.lex_state = 54}, + [530] = {.lex_state = 54}, + [531] = {.lex_state = 54}, + [532] = {.lex_state = 32, .external_lex_state = 1}, + [533] = {.lex_state = 54}, + [534] = {.lex_state = 54}, + [535] = {.lex_state = 54}, + [536] = {.lex_state = 54}, + [537] = {.lex_state = 54}, + [538] = {.lex_state = 54}, + [539] = {.lex_state = 54}, + [540] = {.lex_state = 54}, + [541] = {.lex_state = 54}, + [542] = {.lex_state = 54}, + [543] = {.lex_state = 32, .external_lex_state = 1}, + [544] = {.lex_state = 54}, + [545] = {.lex_state = 54}, + [546] = {.lex_state = 54}, + [547] = {.lex_state = 32}, + [548] = {.lex_state = 32}, + [549] = {.lex_state = 32}, + [550] = {.lex_state = 32}, + [551] = {.lex_state = 32}, + [552] = {.lex_state = 32}, + [553] = {.lex_state = 32}, + [554] = {.lex_state = 32}, + [555] = {.lex_state = 32}, + [556] = {.lex_state = 32}, + [557] = {.lex_state = 32}, + [558] = {.lex_state = 32}, + [559] = {.lex_state = 32}, + [560] = {.lex_state = 32}, + [561] = {.lex_state = 32}, + [562] = {.lex_state = 32}, + [563] = {.lex_state = 32}, + [564] = {.lex_state = 32}, + [565] = {.lex_state = 32}, + [566] = {.lex_state = 32}, + [567] = {.lex_state = 32}, + [568] = {.lex_state = 32}, + [569] = {.lex_state = 32}, + [570] = {.lex_state = 32}, + [571] = {.lex_state = 32}, + [572] = {.lex_state = 32}, + [573] = {.lex_state = 32}, + [574] = {.lex_state = 32}, + [575] = {.lex_state = 734}, + [576] = {.lex_state = 734}, + [577] = {.lex_state = 734}, + [578] = {.lex_state = 734}, + [579] = {.lex_state = 734}, + [580] = {.lex_state = 734}, + [581] = {.lex_state = 734}, + [582] = {.lex_state = 734}, + [583] = {.lex_state = 734}, + [584] = {.lex_state = 734}, + [585] = {.lex_state = 734}, + [586] = {.lex_state = 734}, + [587] = {.lex_state = 734}, + [588] = {.lex_state = 734}, + [589] = {.lex_state = 734}, + [590] = {.lex_state = 734}, + [591] = {.lex_state = 734}, + [592] = {.lex_state = 734}, + [593] = {.lex_state = 734}, + [594] = {.lex_state = 734}, + [595] = {.lex_state = 734}, + [596] = {.lex_state = 734}, + [597] = {.lex_state = 734, .external_lex_state = 1}, + [598] = {.lex_state = 734, .external_lex_state = 1}, + [599] = {.lex_state = 734}, + [600] = {.lex_state = 734}, + [601] = {.lex_state = 734}, + [602] = {.lex_state = 734}, + [603] = {.lex_state = 734}, + [604] = {.lex_state = 734}, + [605] = {.lex_state = 734}, + [606] = {.lex_state = 734}, + [607] = {.lex_state = 734}, + [608] = {.lex_state = 734}, + [609] = {.lex_state = 734}, + [610] = {.lex_state = 734}, + [611] = {.lex_state = 734}, + [612] = {.lex_state = 734}, + [613] = {.lex_state = 734}, + [614] = {.lex_state = 734}, + [615] = {.lex_state = 734}, + [616] = {.lex_state = 734}, + [617] = {.lex_state = 734}, + [618] = {.lex_state = 734}, + [619] = {.lex_state = 734}, + [620] = {.lex_state = 734}, [621] = {.lex_state = 36}, [622] = {.lex_state = 36}, [623] = {.lex_state = 36}, [624] = {.lex_state = 36}, [625] = {.lex_state = 36}, [626] = {.lex_state = 36}, - [627] = {.lex_state = 36}, - [628] = {.lex_state = 36, .external_lex_state = 1}, - [629] = {.lex_state = 48}, - [630] = {.lex_state = 36}, - [631] = {.lex_state = 36}, - [632] = {.lex_state = 36}, - [633] = {.lex_state = 36}, - [634] = {.lex_state = 36}, - [635] = {.lex_state = 36}, - [636] = {.lex_state = 36}, - [637] = {.lex_state = 36}, - [638] = {.lex_state = 36}, - [639] = {.lex_state = 36}, - [640] = {.lex_state = 36}, - [641] = {.lex_state = 36}, - [642] = {.lex_state = 36}, - [643] = {.lex_state = 36}, - [644] = {.lex_state = 52, .external_lex_state = 1}, - [645] = {.lex_state = 36}, - [646] = {.lex_state = 36}, - [647] = {.lex_state = 38, .external_lex_state = 1}, - [648] = {.lex_state = 36}, - [649] = {.lex_state = 36}, - [650] = {.lex_state = 36}, - [651] = {.lex_state = 38, .external_lex_state = 1}, - [652] = {.lex_state = 36}, - [653] = {.lex_state = 52, .external_lex_state = 1}, - [654] = {.lex_state = 36}, - [655] = {.lex_state = 36}, - [656] = {.lex_state = 36}, - [657] = {.lex_state = 36}, - [658] = {.lex_state = 36}, - [659] = {.lex_state = 36}, - [660] = {.lex_state = 36}, - [661] = {.lex_state = 36}, - [662] = {.lex_state = 38}, - [663] = {.lex_state = 38}, - [664] = {.lex_state = 38}, - [665] = {.lex_state = 40, .external_lex_state = 1}, - [666] = {.lex_state = 38}, - [667] = {.lex_state = 38}, - [668] = {.lex_state = 38}, - [669] = {.lex_state = 38}, - [670] = {.lex_state = 38}, - [671] = {.lex_state = 38}, - [672] = {.lex_state = 38}, - [673] = {.lex_state = 38}, - [674] = {.lex_state = 52, .external_lex_state = 1}, - [675] = {.lex_state = 642}, - [676] = {.lex_state = 642}, - [677] = {.lex_state = 40, .external_lex_state = 1}, - [678] = {.lex_state = 40}, - [679] = {.lex_state = 40}, - [680] = {.lex_state = 40}, - [681] = {.lex_state = 40}, - [682] = {.lex_state = 40}, - [683] = {.lex_state = 40}, - [684] = {.lex_state = 40}, - [685] = {.lex_state = 40}, - [686] = {.lex_state = 40}, - [687] = {.lex_state = 40}, - [688] = {.lex_state = 40}, - [689] = {.lex_state = 642}, - [690] = {.lex_state = 38}, - [691] = {.lex_state = 38, .external_lex_state = 1}, - [692] = {.lex_state = 642}, - [693] = {.lex_state = 642}, - [694] = {.lex_state = 38, .external_lex_state = 1}, - [695] = {.lex_state = 642}, - [696] = {.lex_state = 642}, - [697] = {.lex_state = 642}, - [698] = {.lex_state = 642}, - [699] = {.lex_state = 38}, - [700] = {.lex_state = 642}, - [701] = {.lex_state = 642}, - [702] = {.lex_state = 642}, - [703] = {.lex_state = 38}, - [704] = {.lex_state = 38, .external_lex_state = 1}, - [705] = {.lex_state = 642}, - [706] = {.lex_state = 642}, - [707] = {.lex_state = 642}, - [708] = {.lex_state = 642}, - [709] = {.lex_state = 38, .external_lex_state = 1}, - [710] = {.lex_state = 642}, - [711] = {.lex_state = 642}, - [712] = {.lex_state = 642}, - [713] = {.lex_state = 642}, - [714] = {.lex_state = 642}, - [715] = {.lex_state = 642}, - [716] = {.lex_state = 642}, - [717] = {.lex_state = 642}, - [718] = {.lex_state = 642}, - [719] = {.lex_state = 44, .external_lex_state = 1}, - [720] = {.lex_state = 642}, - [721] = {.lex_state = 642}, - [722] = {.lex_state = 40}, - [723] = {.lex_state = 642}, - [724] = {.lex_state = 642}, - [725] = {.lex_state = 642}, - [726] = {.lex_state = 642}, - [727] = {.lex_state = 642}, - [728] = {.lex_state = 642}, - [729] = {.lex_state = 40, .external_lex_state = 1}, - [730] = {.lex_state = 642}, - [731] = {.lex_state = 642}, - [732] = {.lex_state = 642}, - [733] = {.lex_state = 40}, - [734] = {.lex_state = 38}, - [735] = {.lex_state = 642}, - [736] = {.lex_state = 642}, - [737] = {.lex_state = 38}, - [738] = {.lex_state = 38, .external_lex_state = 1}, - [739] = {.lex_state = 642}, - [740] = {.lex_state = 642}, - [741] = {.lex_state = 40}, - [742] = {.lex_state = 38, .external_lex_state = 1}, - [743] = {.lex_state = 642}, - [744] = {.lex_state = 642}, - [745] = {.lex_state = 642}, - [746] = {.lex_state = 44, .external_lex_state = 1}, - [747] = {.lex_state = 642}, - [748] = {.lex_state = 40}, - [749] = {.lex_state = 40, .external_lex_state = 1}, - [750] = {.lex_state = 642}, - [751] = {.lex_state = 40}, - [752] = {.lex_state = 40, .external_lex_state = 1}, - [753] = {.lex_state = 642}, - [754] = {.lex_state = 642}, - [755] = {.lex_state = 642}, - [756] = {.lex_state = 642}, - [757] = {.lex_state = 642}, - [758] = {.lex_state = 642}, - [759] = {.lex_state = 642}, - [760] = {.lex_state = 38}, - [761] = {.lex_state = 642}, - [762] = {.lex_state = 40, .external_lex_state = 1}, - [763] = {.lex_state = 642}, - [764] = {.lex_state = 642}, - [765] = {.lex_state = 642}, - [766] = {.lex_state = 642}, - [767] = {.lex_state = 642}, - [768] = {.lex_state = 642}, - [769] = {.lex_state = 642}, - [770] = {.lex_state = 642}, - [771] = {.lex_state = 38}, - [772] = {.lex_state = 38}, - [773] = {.lex_state = 38}, - [774] = {.lex_state = 38}, - [775] = {.lex_state = 38}, - [776] = {.lex_state = 38}, - [777] = {.lex_state = 38}, - [778] = {.lex_state = 38}, - [779] = {.lex_state = 40, .external_lex_state = 1}, - [780] = {.lex_state = 38}, - [781] = {.lex_state = 38}, - [782] = {.lex_state = 38}, - [783] = {.lex_state = 40}, - [784] = {.lex_state = 38}, - [785] = {.lex_state = 38}, - [786] = {.lex_state = 38}, - [787] = {.lex_state = 38}, - [788] = {.lex_state = 38}, - [789] = {.lex_state = 38}, - [790] = {.lex_state = 38}, - [791] = {.lex_state = 38}, - [792] = {.lex_state = 38}, - [793] = {.lex_state = 40}, - [794] = {.lex_state = 38}, - [795] = {.lex_state = 38}, - [796] = {.lex_state = 38}, - [797] = {.lex_state = 40, .external_lex_state = 1}, - [798] = {.lex_state = 38}, - [799] = {.lex_state = 38}, - [800] = {.lex_state = 40}, - [801] = {.lex_state = 38}, - [802] = {.lex_state = 38}, - [803] = {.lex_state = 38}, - [804] = {.lex_state = 40}, - [805] = {.lex_state = 40}, - [806] = {.lex_state = 40}, - [807] = {.lex_state = 40}, - [808] = {.lex_state = 40}, - [809] = {.lex_state = 40}, - [810] = {.lex_state = 40}, - [811] = {.lex_state = 91}, - [812] = {.lex_state = 40}, - [813] = {.lex_state = 40}, - [814] = {.lex_state = 40}, + [627] = {.lex_state = 734, .external_lex_state = 1}, + [628] = {.lex_state = 734}, + [629] = {.lex_state = 734, .external_lex_state = 1}, + [630] = {.lex_state = 734}, + [631] = {.lex_state = 734}, + [632] = {.lex_state = 734}, + [633] = {.lex_state = 734}, + [634] = {.lex_state = 734, .external_lex_state = 1}, + [635] = {.lex_state = 734}, + [636] = {.lex_state = 734}, + [637] = {.lex_state = 734}, + [638] = {.lex_state = 734}, + [639] = {.lex_state = 734}, + [640] = {.lex_state = 734}, + [641] = {.lex_state = 734}, + [642] = {.lex_state = 734}, + [643] = {.lex_state = 734}, + [644] = {.lex_state = 734}, + [645] = {.lex_state = 734}, + [646] = {.lex_state = 734}, + [647] = {.lex_state = 734}, + [648] = {.lex_state = 734}, + [649] = {.lex_state = 734}, + [650] = {.lex_state = 734}, + [651] = {.lex_state = 734}, + [652] = {.lex_state = 734}, + [653] = {.lex_state = 734}, + [654] = {.lex_state = 734}, + [655] = {.lex_state = 734}, + [656] = {.lex_state = 734}, + [657] = {.lex_state = 734}, + [658] = {.lex_state = 734}, + [659] = {.lex_state = 734}, + [660] = {.lex_state = 734}, + [661] = {.lex_state = 734}, + [662] = {.lex_state = 734}, + [663] = {.lex_state = 734}, + [664] = {.lex_state = 734}, + [665] = {.lex_state = 734}, + [666] = {.lex_state = 734}, + [667] = {.lex_state = 734}, + [668] = {.lex_state = 734}, + [669] = {.lex_state = 734}, + [670] = {.lex_state = 36, .external_lex_state = 1}, + [671] = {.lex_state = 44, .external_lex_state = 1}, + [672] = {.lex_state = 44, .external_lex_state = 1}, + [673] = {.lex_state = 36, .external_lex_state = 1}, + [674] = {.lex_state = 36}, + [675] = {.lex_state = 44}, + [676] = {.lex_state = 38, .external_lex_state = 1}, + [677] = {.lex_state = 36}, + [678] = {.lex_state = 52, .external_lex_state = 1}, + [679] = {.lex_state = 38, .external_lex_state = 1}, + [680] = {.lex_state = 36}, + [681] = {.lex_state = 44}, + [682] = {.lex_state = 44}, + [683] = {.lex_state = 36}, + [684] = {.lex_state = 36}, + [685] = {.lex_state = 36}, + [686] = {.lex_state = 52, .external_lex_state = 1}, + [687] = {.lex_state = 44}, + [688] = {.lex_state = 44}, + [689] = {.lex_state = 44}, + [690] = {.lex_state = 36}, + [691] = {.lex_state = 36}, + [692] = {.lex_state = 36}, + [693] = {.lex_state = 36}, + [694] = {.lex_state = 36}, + [695] = {.lex_state = 44}, + [696] = {.lex_state = 44}, + [697] = {.lex_state = 44}, + [698] = {.lex_state = 44}, + [699] = {.lex_state = 44}, + [700] = {.lex_state = 38}, + [701] = {.lex_state = 734}, + [702] = {.lex_state = 40, .external_lex_state = 1}, + [703] = {.lex_state = 52, .external_lex_state = 1}, + [704] = {.lex_state = 38}, + [705] = {.lex_state = 38}, + [706] = {.lex_state = 38}, + [707] = {.lex_state = 38}, + [708] = {.lex_state = 38}, + [709] = {.lex_state = 40, .external_lex_state = 1}, + [710] = {.lex_state = 38}, + [711] = {.lex_state = 38}, + [712] = {.lex_state = 38}, + [713] = {.lex_state = 38}, + [714] = {.lex_state = 734}, + [715] = {.lex_state = 38}, + [716] = {.lex_state = 36, .external_lex_state = 1}, + [717] = {.lex_state = 36}, + [718] = {.lex_state = 36, .external_lex_state = 1}, + [719] = {.lex_state = 734, .external_lex_state = 1}, + [720] = {.lex_state = 40}, + [721] = {.lex_state = 44, .external_lex_state = 1}, + [722] = {.lex_state = 36}, + [723] = {.lex_state = 44, .external_lex_state = 1}, + [724] = {.lex_state = 36, .external_lex_state = 1}, + [725] = {.lex_state = 40}, + [726] = {.lex_state = 44, .external_lex_state = 1}, + [727] = {.lex_state = 40}, + [728] = {.lex_state = 40}, + [729] = {.lex_state = 40}, + [730] = {.lex_state = 40}, + [731] = {.lex_state = 734}, + [732] = {.lex_state = 36}, + [733] = {.lex_state = 44, .external_lex_state = 1}, + [734] = {.lex_state = 734, .external_lex_state = 1}, + [735] = {.lex_state = 40}, + [736] = {.lex_state = 44}, + [737] = {.lex_state = 40}, + [738] = {.lex_state = 44}, + [739] = {.lex_state = 40}, + [740] = {.lex_state = 40}, + [741] = {.lex_state = 44}, + [742] = {.lex_state = 40}, + [743] = {.lex_state = 36, .external_lex_state = 1}, + [744] = {.lex_state = 38}, + [745] = {.lex_state = 44}, + [746] = {.lex_state = 734}, + [747] = {.lex_state = 734}, + [748] = {.lex_state = 734}, + [749] = {.lex_state = 734}, + [750] = {.lex_state = 734}, + [751] = {.lex_state = 734}, + [752] = {.lex_state = 734}, + [753] = {.lex_state = 734}, + [754] = {.lex_state = 734}, + [755] = {.lex_state = 734}, + [756] = {.lex_state = 734}, + [757] = {.lex_state = 734}, + [758] = {.lex_state = 734}, + [759] = {.lex_state = 36}, + [760] = {.lex_state = 36, .external_lex_state = 1}, + [761] = {.lex_state = 734}, + [762] = {.lex_state = 44, .external_lex_state = 1}, + [763] = {.lex_state = 38, .external_lex_state = 1}, + [764] = {.lex_state = 38, .external_lex_state = 1}, + [765] = {.lex_state = 734}, + [766] = {.lex_state = 38}, + [767] = {.lex_state = 38}, + [768] = {.lex_state = 38, .external_lex_state = 1}, + [769] = {.lex_state = 36}, + [770] = {.lex_state = 36}, + [771] = {.lex_state = 42}, + [772] = {.lex_state = 38, .external_lex_state = 1}, + [773] = {.lex_state = 36, .external_lex_state = 1}, + [774] = {.lex_state = 42}, + [775] = {.lex_state = 734}, + [776] = {.lex_state = 734}, + [777] = {.lex_state = 36}, + [778] = {.lex_state = 734}, + [779] = {.lex_state = 734}, + [780] = {.lex_state = 46, .external_lex_state = 1}, + [781] = {.lex_state = 734}, + [782] = {.lex_state = 734}, + [783] = {.lex_state = 734}, + [784] = {.lex_state = 36}, + [785] = {.lex_state = 36}, + [786] = {.lex_state = 36}, + [787] = {.lex_state = 36}, + [788] = {.lex_state = 36}, + [789] = {.lex_state = 36}, + [790] = {.lex_state = 36}, + [791] = {.lex_state = 36}, + [792] = {.lex_state = 36}, + [793] = {.lex_state = 36}, + [794] = {.lex_state = 36}, + [795] = {.lex_state = 36}, + [796] = {.lex_state = 36}, + [797] = {.lex_state = 36}, + [798] = {.lex_state = 38, .external_lex_state = 1}, + [799] = {.lex_state = 734}, + [800] = {.lex_state = 734}, + [801] = {.lex_state = 734}, + [802] = {.lex_state = 36}, + [803] = {.lex_state = 734}, + [804] = {.lex_state = 36}, + [805] = {.lex_state = 734}, + [806] = {.lex_state = 734}, + [807] = {.lex_state = 734}, + [808] = {.lex_state = 734}, + [809] = {.lex_state = 734}, + [810] = {.lex_state = 36}, + [811] = {.lex_state = 36}, + [812] = {.lex_state = 734}, + [813] = {.lex_state = 36}, + [814] = {.lex_state = 40, .external_lex_state = 1}, [815] = {.lex_state = 40}, - [816] = {.lex_state = 40}, - [817] = {.lex_state = 643}, - [818] = {.lex_state = 643}, - [819] = {.lex_state = 40}, - [820] = {.lex_state = 643}, - [821] = {.lex_state = 40}, - [822] = {.lex_state = 40}, - [823] = {.lex_state = 40}, - [824] = {.lex_state = 40}, - [825] = {.lex_state = 40}, - [826] = {.lex_state = 40}, - [827] = {.lex_state = 40}, - [828] = {.lex_state = 40}, - [829] = {.lex_state = 91}, - [830] = {.lex_state = 40}, + [816] = {.lex_state = 734}, + [817] = {.lex_state = 36}, + [818] = {.lex_state = 36}, + [819] = {.lex_state = 36}, + [820] = {.lex_state = 40, .external_lex_state = 1}, + [821] = {.lex_state = 36}, + [822] = {.lex_state = 734}, + [823] = {.lex_state = 734}, + [824] = {.lex_state = 36}, + [825] = {.lex_state = 36}, + [826] = {.lex_state = 734}, + [827] = {.lex_state = 734}, + [828] = {.lex_state = 46, .external_lex_state = 1}, + [829] = {.lex_state = 36}, + [830] = {.lex_state = 36}, [831] = {.lex_state = 40}, - [832] = {.lex_state = 40}, - [833] = {.lex_state = 40}, + [832] = {.lex_state = 734}, + [833] = {.lex_state = 40, .external_lex_state = 1}, [834] = {.lex_state = 40}, - [835] = {.lex_state = 40}, - [836] = {.lex_state = 40}, - [837] = {.lex_state = 40}, - [838] = {.lex_state = 40}, - [839] = {.lex_state = 91}, - [840] = {.lex_state = 642, .external_lex_state = 1}, - [841] = {.lex_state = 642, .external_lex_state = 1}, - [842] = {.lex_state = 642, .external_lex_state = 1}, - [843] = {.lex_state = 642, .external_lex_state = 1}, - [844] = {.lex_state = 642, .external_lex_state = 1}, - [845] = {.lex_state = 642, .external_lex_state = 1}, - [846] = {.lex_state = 642, .external_lex_state = 1}, - [847] = {.lex_state = 642, .external_lex_state = 1}, - [848] = {.lex_state = 642, .external_lex_state = 1}, - [849] = {.lex_state = 642, .external_lex_state = 1}, - [850] = {.lex_state = 91}, - [851] = {.lex_state = 643}, - [852] = {.lex_state = 643}, - [853] = {.lex_state = 643}, - [854] = {.lex_state = 643}, - [855] = {.lex_state = 643}, - [856] = {.lex_state = 643}, - [857] = {.lex_state = 643}, - [858] = {.lex_state = 643}, - [859] = {.lex_state = 643}, - [860] = {.lex_state = 643}, - [861] = {.lex_state = 643}, - [862] = {.lex_state = 643}, - [863] = {.lex_state = 643}, - [864] = {.lex_state = 643}, - [865] = {.lex_state = 643}, - [866] = {.lex_state = 643}, - [867] = {.lex_state = 643}, - [868] = {.lex_state = 643}, - [869] = {.lex_state = 643}, - [870] = {.lex_state = 643}, - [871] = {.lex_state = 643}, - [872] = {.lex_state = 643}, - [873] = {.lex_state = 643}, - [874] = {.lex_state = 643}, - [875] = {.lex_state = 643}, - [876] = {.lex_state = 643}, - [877] = {.lex_state = 643}, - [878] = {.lex_state = 91}, - [879] = {.lex_state = 643}, - [880] = {.lex_state = 643}, - [881] = {.lex_state = 643}, - [882] = {.lex_state = 643}, - [883] = {.lex_state = 643}, - [884] = {.lex_state = 643}, - [885] = {.lex_state = 643}, - [886] = {.lex_state = 643}, - [887] = {.lex_state = 643}, - [888] = {.lex_state = 643}, - [889] = {.lex_state = 643}, - [890] = {.lex_state = 643}, - [891] = {.lex_state = 643}, - [892] = {.lex_state = 643}, - [893] = {.lex_state = 643}, - [894] = {.lex_state = 643}, - [895] = {.lex_state = 643}, - [896] = {.lex_state = 643}, - [897] = {.lex_state = 643}, - [898] = {.lex_state = 643}, - [899] = {.lex_state = 643}, - [900] = {.lex_state = 643}, - [901] = {.lex_state = 643}, - [902] = {.lex_state = 643}, - [903] = {.lex_state = 643}, - [904] = {.lex_state = 643}, - [905] = {.lex_state = 643}, - [906] = {.lex_state = 643}, - [907] = {.lex_state = 643}, - [908] = {.lex_state = 643}, - [909] = {.lex_state = 643}, - [910] = {.lex_state = 643}, - [911] = {.lex_state = 643}, - [912] = {.lex_state = 643}, - [913] = {.lex_state = 643}, - [914] = {.lex_state = 643}, - [915] = {.lex_state = 643}, - [916] = {.lex_state = 643}, - [917] = {.lex_state = 643}, - [918] = {.lex_state = 643}, - [919] = {.lex_state = 643}, - [920] = {.lex_state = 643}, - [921] = {.lex_state = 91}, - [922] = {.lex_state = 91}, - [923] = {.lex_state = 91}, - [924] = {.lex_state = 91}, - [925] = {.lex_state = 91}, - [926] = {.lex_state = 91}, - [927] = {.lex_state = 91}, - [928] = {.lex_state = 91}, - [929] = {.lex_state = 643}, - [930] = {.lex_state = 91}, - [931] = {.lex_state = 91}, - [932] = {.lex_state = 91}, - [933] = {.lex_state = 91}, - [934] = {.lex_state = 91}, - [935] = {.lex_state = 91}, - [936] = {.lex_state = 91}, - [937] = {.lex_state = 91}, - [938] = {.lex_state = 91}, - [939] = {.lex_state = 91}, - [940] = {.lex_state = 91}, - [941] = {.lex_state = 91}, - [942] = {.lex_state = 91}, - [943] = {.lex_state = 91}, - [944] = {.lex_state = 91}, - [945] = {.lex_state = 91}, - [946] = {.lex_state = 91}, - [947] = {.lex_state = 91}, - [948] = {.lex_state = 91}, - [949] = {.lex_state = 91}, - [950] = {.lex_state = 91}, - [951] = {.lex_state = 91}, - [952] = {.lex_state = 91}, - [953] = {.lex_state = 91}, - [954] = {.lex_state = 91}, - [955] = {.lex_state = 91}, - [956] = {.lex_state = 91}, - [957] = {.lex_state = 91}, - [958] = {.lex_state = 91}, - [959] = {.lex_state = 91}, - [960] = {.lex_state = 91}, - [961] = {.lex_state = 91}, - [962] = {.lex_state = 643}, - [963] = {.lex_state = 91}, - [964] = {.lex_state = 91}, - [965] = {.lex_state = 91}, - [966] = {.lex_state = 91}, - [967] = {.lex_state = 91}, - [968] = {.lex_state = 91}, - [969] = {.lex_state = 91}, - [970] = {.lex_state = 91}, - [971] = {.lex_state = 91}, - [972] = {.lex_state = 91}, - [973] = {.lex_state = 91}, - [974] = {.lex_state = 91}, - [975] = {.lex_state = 91}, - [976] = {.lex_state = 91}, - [977] = {.lex_state = 91}, - [978] = {.lex_state = 642, .external_lex_state = 1}, - [979] = {.lex_state = 91}, - [980] = {.lex_state = 91}, - [981] = {.lex_state = 91}, - [982] = {.lex_state = 91}, - [983] = {.lex_state = 91}, - [984] = {.lex_state = 91}, - [985] = {.lex_state = 91}, - [986] = {.lex_state = 91}, - [987] = {.lex_state = 91}, - [988] = {.lex_state = 91}, - [989] = {.lex_state = 91}, - [990] = {.lex_state = 91}, - [991] = {.lex_state = 91}, - [992] = {.lex_state = 91}, - [993] = {.lex_state = 91}, - [994] = {.lex_state = 91}, - [995] = {.lex_state = 91}, - [996] = {.lex_state = 91}, - [997] = {.lex_state = 91}, - [998] = {.lex_state = 643}, - [999] = {.lex_state = 643}, - [1000] = {.lex_state = 643}, - [1001] = {.lex_state = 643}, - [1002] = {.lex_state = 643}, - [1003] = {.lex_state = 644}, - [1004] = {.lex_state = 92}, - [1005] = {.lex_state = 644}, - [1006] = {.lex_state = 644}, - [1007] = {.lex_state = 644}, - [1008] = {.lex_state = 644}, - [1009] = {.lex_state = 644}, - [1010] = {.lex_state = 644}, - [1011] = {.lex_state = 644}, - [1012] = {.lex_state = 644}, - [1013] = {.lex_state = 644}, - [1014] = {.lex_state = 644}, - [1015] = {.lex_state = 642}, - [1016] = {.lex_state = 60}, - [1017] = {.lex_state = 644}, - [1018] = {.lex_state = 644}, - [1019] = {.lex_state = 644}, - [1020] = {.lex_state = 642}, - [1021] = {.lex_state = 644}, - [1022] = {.lex_state = 644}, - [1023] = {.lex_state = 644}, - [1024] = {.lex_state = 644}, - [1025] = {.lex_state = 644}, - [1026] = {.lex_state = 644}, - [1027] = {.lex_state = 644}, - [1028] = {.lex_state = 644}, - [1029] = {.lex_state = 644}, - [1030] = {.lex_state = 644}, - [1031] = {.lex_state = 644}, - [1032] = {.lex_state = 644}, - [1033] = {.lex_state = 644}, - [1034] = {.lex_state = 644}, - [1035] = {.lex_state = 644}, - [1036] = {.lex_state = 644}, - [1037] = {.lex_state = 644}, - [1038] = {.lex_state = 644}, - [1039] = {.lex_state = 644}, - [1040] = {.lex_state = 644}, - [1041] = {.lex_state = 644}, - [1042] = {.lex_state = 644}, - [1043] = {.lex_state = 644}, - [1044] = {.lex_state = 644}, - [1045] = {.lex_state = 644}, - [1046] = {.lex_state = 644}, - [1047] = {.lex_state = 644}, - [1048] = {.lex_state = 644}, - [1049] = {.lex_state = 644}, - [1050] = {.lex_state = 644}, - [1051] = {.lex_state = 642}, - [1052] = {.lex_state = 644}, - [1053] = {.lex_state = 644}, - [1054] = {.lex_state = 644}, - [1055] = {.lex_state = 644}, - [1056] = {.lex_state = 644}, - [1057] = {.lex_state = 644}, - [1058] = {.lex_state = 644}, - [1059] = {.lex_state = 644}, - [1060] = {.lex_state = 644}, - [1061] = {.lex_state = 644}, - [1062] = {.lex_state = 644}, - [1063] = {.lex_state = 642}, - [1064] = {.lex_state = 644}, - [1065] = {.lex_state = 644}, - [1066] = {.lex_state = 644}, - [1067] = {.lex_state = 644}, - [1068] = {.lex_state = 644}, - [1069] = {.lex_state = 644}, - [1070] = {.lex_state = 644}, - [1071] = {.lex_state = 644}, - [1072] = {.lex_state = 644}, - [1073] = {.lex_state = 644}, - [1074] = {.lex_state = 644}, - [1075] = {.lex_state = 60}, - [1076] = {.lex_state = 644}, - [1077] = {.lex_state = 644}, - [1078] = {.lex_state = 644}, - [1079] = {.lex_state = 644}, - [1080] = {.lex_state = 644}, - [1081] = {.lex_state = 644}, - [1082] = {.lex_state = 644}, - [1083] = {.lex_state = 644}, - [1084] = {.lex_state = 644}, - [1085] = {.lex_state = 644}, - [1086] = {.lex_state = 644}, - [1087] = {.lex_state = 644}, - [1088] = {.lex_state = 644}, - [1089] = {.lex_state = 644}, - [1090] = {.lex_state = 644}, - [1091] = {.lex_state = 644}, - [1092] = {.lex_state = 644}, - [1093] = {.lex_state = 644}, - [1094] = {.lex_state = 644}, - [1095] = {.lex_state = 644}, - [1096] = {.lex_state = 644}, - [1097] = {.lex_state = 642}, - [1098] = {.lex_state = 644}, - [1099] = {.lex_state = 644}, - [1100] = {.lex_state = 644}, - [1101] = {.lex_state = 644}, - [1102] = {.lex_state = 644}, - [1103] = {.lex_state = 644}, - [1104] = {.lex_state = 644}, - [1105] = {.lex_state = 644}, - [1106] = {.lex_state = 644}, - [1107] = {.lex_state = 644}, - [1108] = {.lex_state = 644}, - [1109] = {.lex_state = 644}, - [1110] = {.lex_state = 644}, - [1111] = {.lex_state = 644}, - [1112] = {.lex_state = 644}, - [1113] = {.lex_state = 644}, - [1114] = {.lex_state = 644}, - [1115] = {.lex_state = 644}, - [1116] = {.lex_state = 644}, - [1117] = {.lex_state = 644}, - [1118] = {.lex_state = 642}, - [1119] = {.lex_state = 644}, - [1120] = {.lex_state = 644}, - [1121] = {.lex_state = 644}, - [1122] = {.lex_state = 644}, - [1123] = {.lex_state = 644}, - [1124] = {.lex_state = 644}, - [1125] = {.lex_state = 644}, - [1126] = {.lex_state = 644}, - [1127] = {.lex_state = 644}, - [1128] = {.lex_state = 644}, - [1129] = {.lex_state = 644}, - [1130] = {.lex_state = 644}, - [1131] = {.lex_state = 644}, - [1132] = {.lex_state = 644}, - [1133] = {.lex_state = 644}, - [1134] = {.lex_state = 644}, - [1135] = {.lex_state = 644}, - [1136] = {.lex_state = 644}, - [1137] = {.lex_state = 644}, - [1138] = {.lex_state = 644}, - [1139] = {.lex_state = 92}, - [1140] = {.lex_state = 92}, - [1141] = {.lex_state = 92}, - [1142] = {.lex_state = 92}, - [1143] = {.lex_state = 92}, - [1144] = {.lex_state = 644}, - [1145] = {.lex_state = 92}, - [1146] = {.lex_state = 644}, - [1147] = {.lex_state = 644}, - [1148] = {.lex_state = 644}, - [1149] = {.lex_state = 644}, - [1150] = {.lex_state = 644}, - [1151] = {.lex_state = 644}, - [1152] = {.lex_state = 644}, - [1153] = {.lex_state = 644}, - [1154] = {.lex_state = 644}, - [1155] = {.lex_state = 644}, - [1156] = {.lex_state = 644}, - [1157] = {.lex_state = 644}, - [1158] = {.lex_state = 92}, - [1159] = {.lex_state = 92}, - [1160] = {.lex_state = 92}, - [1161] = {.lex_state = 92}, - [1162] = {.lex_state = 644}, - [1163] = {.lex_state = 644}, - [1164] = {.lex_state = 644}, - [1165] = {.lex_state = 644}, - [1166] = {.lex_state = 644}, - [1167] = {.lex_state = 644}, - [1168] = {.lex_state = 644}, - [1169] = {.lex_state = 644}, - [1170] = {.lex_state = 644}, - [1171] = {.lex_state = 644}, - [1172] = {.lex_state = 642}, - [1173] = {.lex_state = 644}, - [1174] = {.lex_state = 644}, - [1175] = {.lex_state = 644}, - [1176] = {.lex_state = 644}, - [1177] = {.lex_state = 644}, - [1178] = {.lex_state = 644}, - [1179] = {.lex_state = 644}, - [1180] = {.lex_state = 644}, - [1181] = {.lex_state = 644}, - [1182] = {.lex_state = 644}, - [1183] = {.lex_state = 644}, - [1184] = {.lex_state = 644}, - [1185] = {.lex_state = 92}, - [1186] = {.lex_state = 92}, - [1187] = {.lex_state = 92}, - [1188] = {.lex_state = 92}, - [1189] = {.lex_state = 92}, - [1190] = {.lex_state = 92}, - [1191] = {.lex_state = 92}, - [1192] = {.lex_state = 92}, - [1193] = {.lex_state = 92}, - [1194] = {.lex_state = 644}, - [1195] = {.lex_state = 644}, - [1196] = {.lex_state = 644}, - [1197] = {.lex_state = 644}, - [1198] = {.lex_state = 644}, - [1199] = {.lex_state = 644}, - [1200] = {.lex_state = 644}, - [1201] = {.lex_state = 644}, - [1202] = {.lex_state = 644}, - [1203] = {.lex_state = 644}, - [1204] = {.lex_state = 92}, - [1205] = {.lex_state = 92}, - [1206] = {.lex_state = 642}, - [1207] = {.lex_state = 644}, - [1208] = {.lex_state = 92}, - [1209] = {.lex_state = 92}, - [1210] = {.lex_state = 92}, - [1211] = {.lex_state = 92}, - [1212] = {.lex_state = 92}, - [1213] = {.lex_state = 92}, - [1214] = {.lex_state = 92}, - [1215] = {.lex_state = 92}, - [1216] = {.lex_state = 92}, - [1217] = {.lex_state = 92}, - [1218] = {.lex_state = 92}, - [1219] = {.lex_state = 92}, - [1220] = {.lex_state = 92}, - [1221] = {.lex_state = 92}, - [1222] = {.lex_state = 92}, - [1223] = {.lex_state = 92}, - [1224] = {.lex_state = 92}, - [1225] = {.lex_state = 92}, - [1226] = {.lex_state = 92}, - [1227] = {.lex_state = 92}, - [1228] = {.lex_state = 644}, - [1229] = {.lex_state = 92}, - [1230] = {.lex_state = 92}, - [1231] = {.lex_state = 92}, - [1232] = {.lex_state = 92}, - [1233] = {.lex_state = 92}, - [1234] = {.lex_state = 92}, - [1235] = {.lex_state = 92}, - [1236] = {.lex_state = 644}, - [1237] = {.lex_state = 92}, - [1238] = {.lex_state = 92}, - [1239] = {.lex_state = 92}, - [1240] = {.lex_state = 92}, - [1241] = {.lex_state = 92}, - [1242] = {.lex_state = 92}, - [1243] = {.lex_state = 92}, - [1244] = {.lex_state = 92}, - [1245] = {.lex_state = 92}, - [1246] = {.lex_state = 92}, - [1247] = {.lex_state = 644}, - [1248] = {.lex_state = 92}, - [1249] = {.lex_state = 92}, - [1250] = {.lex_state = 92}, - [1251] = {.lex_state = 644}, - [1252] = {.lex_state = 642}, - [1253] = {.lex_state = 92}, - [1254] = {.lex_state = 92}, - [1255] = {.lex_state = 92}, - [1256] = {.lex_state = 92}, - [1257] = {.lex_state = 92}, - [1258] = {.lex_state = 92}, - [1259] = {.lex_state = 92}, - [1260] = {.lex_state = 92}, - [1261] = {.lex_state = 644}, - [1262] = {.lex_state = 92}, - [1263] = {.lex_state = 92}, - [1264] = {.lex_state = 92}, - [1265] = {.lex_state = 92}, - [1266] = {.lex_state = 92}, - [1267] = {.lex_state = 92}, - [1268] = {.lex_state = 92}, - [1269] = {.lex_state = 92}, - [1270] = {.lex_state = 92}, - [1271] = {.lex_state = 92}, - [1272] = {.lex_state = 92}, - [1273] = {.lex_state = 92}, - [1274] = {.lex_state = 92}, - [1275] = {.lex_state = 92}, - [1276] = {.lex_state = 644}, - [1277] = {.lex_state = 92}, - [1278] = {.lex_state = 644}, - [1279] = {.lex_state = 644}, - [1280] = {.lex_state = 92}, - [1281] = {.lex_state = 92}, - [1282] = {.lex_state = 92}, - [1283] = {.lex_state = 92}, - [1284] = {.lex_state = 92}, - [1285] = {.lex_state = 92}, - [1286] = {.lex_state = 92}, - [1287] = {.lex_state = 644}, - [1288] = {.lex_state = 92}, - [1289] = {.lex_state = 92}, - [1290] = {.lex_state = 92}, - [1291] = {.lex_state = 644}, - [1292] = {.lex_state = 644}, - [1293] = {.lex_state = 92}, - [1294] = {.lex_state = 644}, - [1295] = {.lex_state = 92}, - [1296] = {.lex_state = 92}, - [1297] = {.lex_state = 92}, - [1298] = {.lex_state = 92}, - [1299] = {.lex_state = 92}, - [1300] = {.lex_state = 92}, - [1301] = {.lex_state = 92}, - [1302] = {.lex_state = 92}, - [1303] = {.lex_state = 92}, - [1304] = {.lex_state = 92}, - [1305] = {.lex_state = 92}, - [1306] = {.lex_state = 92}, - [1307] = {.lex_state = 92}, - [1308] = {.lex_state = 92}, - [1309] = {.lex_state = 92}, - [1310] = {.lex_state = 92}, - [1311] = {.lex_state = 92}, - [1312] = {.lex_state = 92}, - [1313] = {.lex_state = 92}, - [1314] = {.lex_state = 92}, - [1315] = {.lex_state = 92}, - [1316] = {.lex_state = 92}, - [1317] = {.lex_state = 92}, - [1318] = {.lex_state = 92}, - [1319] = {.lex_state = 92}, - [1320] = {.lex_state = 92}, - [1321] = {.lex_state = 92}, - [1322] = {.lex_state = 92}, - [1323] = {.lex_state = 92}, - [1324] = {.lex_state = 644}, - [1325] = {.lex_state = 92}, - [1326] = {.lex_state = 92}, - [1327] = {.lex_state = 92}, - [1328] = {.lex_state = 92}, - [1329] = {.lex_state = 92}, - [1330] = {.lex_state = 92}, - [1331] = {.lex_state = 92}, - [1332] = {.lex_state = 92}, - [1333] = {.lex_state = 92}, - [1334] = {.lex_state = 644}, - [1335] = {.lex_state = 92}, - [1336] = {.lex_state = 92}, - [1337] = {.lex_state = 92}, - [1338] = {.lex_state = 92}, - [1339] = {.lex_state = 644}, - [1340] = {.lex_state = 92}, - [1341] = {.lex_state = 92}, - [1342] = {.lex_state = 92}, - [1343] = {.lex_state = 92}, - [1344] = {.lex_state = 92}, - [1345] = {.lex_state = 92}, - [1346] = {.lex_state = 92}, - [1347] = {.lex_state = 92}, - [1348] = {.lex_state = 92}, - [1349] = {.lex_state = 92}, - [1350] = {.lex_state = 92}, - [1351] = {.lex_state = 92}, - [1352] = {.lex_state = 92}, - [1353] = {.lex_state = 92}, - [1354] = {.lex_state = 92}, - [1355] = {.lex_state = 92}, - [1356] = {.lex_state = 92}, - [1357] = {.lex_state = 92}, - [1358] = {.lex_state = 92}, - [1359] = {.lex_state = 92}, - [1360] = {.lex_state = 92}, - [1361] = {.lex_state = 92}, - [1362] = {.lex_state = 92}, - [1363] = {.lex_state = 644}, - [1364] = {.lex_state = 92}, - [1365] = {.lex_state = 92}, - [1366] = {.lex_state = 92}, - [1367] = {.lex_state = 92}, - [1368] = {.lex_state = 92}, - [1369] = {.lex_state = 92}, - [1370] = {.lex_state = 92}, - [1371] = {.lex_state = 92}, - [1372] = {.lex_state = 92}, - [1373] = {.lex_state = 642}, - [1374] = {.lex_state = 644}, - [1375] = {.lex_state = 92}, - [1376] = {.lex_state = 92}, - [1377] = {.lex_state = 92}, - [1378] = {.lex_state = 92}, - [1379] = {.lex_state = 92}, - [1380] = {.lex_state = 92}, - [1381] = {.lex_state = 92}, - [1382] = {.lex_state = 92}, - [1383] = {.lex_state = 92}, - [1384] = {.lex_state = 92}, - [1385] = {.lex_state = 92}, - [1386] = {.lex_state = 92}, - [1387] = {.lex_state = 92}, - [1388] = {.lex_state = 92}, - [1389] = {.lex_state = 92}, - [1390] = {.lex_state = 92}, - [1391] = {.lex_state = 92}, - [1392] = {.lex_state = 92}, - [1393] = {.lex_state = 92}, - [1394] = {.lex_state = 92}, - [1395] = {.lex_state = 642}, - [1396] = {.lex_state = 642}, - [1397] = {.lex_state = 54}, - [1398] = {.lex_state = 642}, - [1399] = {.lex_state = 642}, - [1400] = {.lex_state = 642}, - [1401] = {.lex_state = 54}, - [1402] = {.lex_state = 642}, - [1403] = {.lex_state = 54}, - [1404] = {.lex_state = 54}, - [1405] = {.lex_state = 54}, - [1406] = {.lex_state = 642}, - [1407] = {.lex_state = 642}, - [1408] = {.lex_state = 642}, - [1409] = {.lex_state = 642}, - [1410] = {.lex_state = 642}, - [1411] = {.lex_state = 642}, - [1412] = {.lex_state = 642}, - [1413] = {.lex_state = 642}, - [1414] = {.lex_state = 642}, - [1415] = {.lex_state = 642}, - [1416] = {.lex_state = 642}, - [1417] = {.lex_state = 642}, - [1418] = {.lex_state = 642}, - [1419] = {.lex_state = 642}, - [1420] = {.lex_state = 642}, - [1421] = {.lex_state = 642}, - [1422] = {.lex_state = 642}, - [1423] = {.lex_state = 642}, - [1424] = {.lex_state = 642}, - [1425] = {.lex_state = 642}, - [1426] = {.lex_state = 642}, - [1427] = {.lex_state = 642}, - [1428] = {.lex_state = 642}, - [1429] = {.lex_state = 642}, - [1430] = {.lex_state = 642}, - [1431] = {.lex_state = 642}, - [1432] = {.lex_state = 50}, - [1433] = {.lex_state = 642}, - [1434] = {.lex_state = 50}, - [1435] = {.lex_state = 50}, - [1436] = {.lex_state = 50}, - [1437] = {.lex_state = 50}, - [1438] = {.lex_state = 60}, - [1439] = {.lex_state = 642}, - [1440] = {.lex_state = 50}, - [1441] = {.lex_state = 50}, - [1442] = {.lex_state = 50}, - [1443] = {.lex_state = 50}, - [1444] = {.lex_state = 50}, - [1445] = {.lex_state = 50}, - [1446] = {.lex_state = 60}, - [1447] = {.lex_state = 642}, - [1448] = {.lex_state = 642}, - [1449] = {.lex_state = 642}, - [1450] = {.lex_state = 642}, - [1451] = {.lex_state = 642}, - [1452] = {.lex_state = 642}, - [1453] = {.lex_state = 642}, - [1454] = {.lex_state = 642}, - [1455] = {.lex_state = 642}, - [1456] = {.lex_state = 642}, - [1457] = {.lex_state = 642}, - [1458] = {.lex_state = 642}, - [1459] = {.lex_state = 642}, - [1460] = {.lex_state = 642}, - [1461] = {.lex_state = 642}, - [1462] = {.lex_state = 642}, - [1463] = {.lex_state = 642}, - [1464] = {.lex_state = 642}, - [1465] = {.lex_state = 642}, - [1466] = {.lex_state = 642}, - [1467] = {.lex_state = 642}, - [1468] = {.lex_state = 642}, - [1469] = {.lex_state = 642}, - [1470] = {.lex_state = 642}, - [1471] = {.lex_state = 642}, - [1472] = {.lex_state = 642}, - [1473] = {.lex_state = 642}, - [1474] = {.lex_state = 642}, - [1475] = {.lex_state = 642}, - [1476] = {.lex_state = 642}, - [1477] = {.lex_state = 642}, - [1478] = {.lex_state = 642}, - [1479] = {.lex_state = 642}, - [1480] = {.lex_state = 642}, - [1481] = {.lex_state = 642}, - [1482] = {.lex_state = 642}, - [1483] = {.lex_state = 642}, - [1484] = {.lex_state = 642}, - [1485] = {.lex_state = 642}, - [1486] = {.lex_state = 642}, - [1487] = {.lex_state = 642}, - [1488] = {.lex_state = 96}, - [1489] = {.lex_state = 642}, - [1490] = {.lex_state = 642}, - [1491] = {.lex_state = 642}, - [1492] = {.lex_state = 642}, - [1493] = {.lex_state = 642}, - [1494] = {.lex_state = 642}, - [1495] = {.lex_state = 642}, - [1496] = {.lex_state = 642}, - [1497] = {.lex_state = 642}, - [1498] = {.lex_state = 642}, - [1499] = {.lex_state = 642}, - [1500] = {.lex_state = 642}, - [1501] = {.lex_state = 642}, - [1502] = {.lex_state = 642}, - [1503] = {.lex_state = 642}, - [1504] = {.lex_state = 642}, - [1505] = {.lex_state = 642}, - [1506] = {.lex_state = 642}, - [1507] = {.lex_state = 642}, - [1508] = {.lex_state = 642}, - [1509] = {.lex_state = 642}, - [1510] = {.lex_state = 642}, - [1511] = {.lex_state = 642}, - [1512] = {.lex_state = 642}, - [1513] = {.lex_state = 642}, - [1514] = {.lex_state = 642}, - [1515] = {.lex_state = 642}, - [1516] = {.lex_state = 642}, - [1517] = {.lex_state = 642}, - [1518] = {.lex_state = 96}, - [1519] = {.lex_state = 642, .external_lex_state = 1}, - [1520] = {.lex_state = 96}, - [1521] = {.lex_state = 642}, - [1522] = {.lex_state = 96}, - [1523] = {.lex_state = 642}, - [1524] = {.lex_state = 96}, - [1525] = {.lex_state = 642}, - [1526] = {.lex_state = 642}, - [1527] = {.lex_state = 642}, - [1528] = {.lex_state = 642}, - [1529] = {.lex_state = 642}, - [1530] = {.lex_state = 96}, - [1531] = {.lex_state = 96}, - [1532] = {.lex_state = 96}, - [1533] = {.lex_state = 642}, - [1534] = {.lex_state = 60}, - [1535] = {.lex_state = 642, .external_lex_state = 1}, - [1536] = {.lex_state = 642}, - [1537] = {.lex_state = 642}, - [1538] = {.lex_state = 60}, - [1539] = {.lex_state = 60}, - [1540] = {.lex_state = 642, .external_lex_state = 1}, - [1541] = {.lex_state = 642, .external_lex_state = 1}, - [1542] = {.lex_state = 642, .external_lex_state = 1}, - [1543] = {.lex_state = 642}, - [1544] = {.lex_state = 60, .external_lex_state = 1}, - [1545] = {.lex_state = 642}, - [1546] = {.lex_state = 642}, - [1547] = {.lex_state = 642}, - [1548] = {.lex_state = 642}, - [1549] = {.lex_state = 642}, - [1550] = {.lex_state = 60, .external_lex_state = 1}, - [1551] = {.lex_state = 642}, - [1552] = {.lex_state = 642}, - [1553] = {.lex_state = 642}, - [1554] = {.lex_state = 642}, - [1555] = {.lex_state = 642}, - [1556] = {.lex_state = 642}, - [1557] = {.lex_state = 642}, - [1558] = {.lex_state = 642}, - [1559] = {.lex_state = 642}, - [1560] = {.lex_state = 642}, - [1561] = {.lex_state = 642}, - [1562] = {.lex_state = 642}, - [1563] = {.lex_state = 642}, - [1564] = {.lex_state = 642}, - [1565] = {.lex_state = 642}, - [1566] = {.lex_state = 58, .external_lex_state = 1}, - [1567] = {.lex_state = 642}, - [1568] = {.lex_state = 60}, - [1569] = {.lex_state = 60}, - [1570] = {.lex_state = 642}, - [1571] = {.lex_state = 60}, - [1572] = {.lex_state = 642}, - [1573] = {.lex_state = 642}, - [1574] = {.lex_state = 642}, - [1575] = {.lex_state = 642}, - [1576] = {.lex_state = 60}, - [1577] = {.lex_state = 60}, - [1578] = {.lex_state = 60}, - [1579] = {.lex_state = 60}, - [1580] = {.lex_state = 36}, - [1581] = {.lex_state = 60}, - [1582] = {.lex_state = 60}, - [1583] = {.lex_state = 60}, - [1584] = {.lex_state = 60}, - [1585] = {.lex_state = 60}, - [1586] = {.lex_state = 60}, - [1587] = {.lex_state = 36, .external_lex_state = 1}, - [1588] = {.lex_state = 36}, - [1589] = {.lex_state = 36}, - [1590] = {.lex_state = 36}, - [1591] = {.lex_state = 642}, - [1592] = {.lex_state = 58, .external_lex_state = 1}, - [1593] = {.lex_state = 88}, - [1594] = {.lex_state = 88}, - [1595] = {.lex_state = 58, .external_lex_state = 1}, - [1596] = {.lex_state = 60}, - [1597] = {.lex_state = 642}, - [1598] = {.lex_state = 60}, - [1599] = {.lex_state = 36}, - [1600] = {.lex_state = 60}, - [1601] = {.lex_state = 642}, - [1602] = {.lex_state = 36}, - [1603] = {.lex_state = 642}, - [1604] = {.lex_state = 60}, - [1605] = {.lex_state = 60}, - [1606] = {.lex_state = 36}, - [1607] = {.lex_state = 36}, - [1608] = {.lex_state = 642}, - [1609] = {.lex_state = 59, .external_lex_state = 1}, - [1610] = {.lex_state = 36}, - [1611] = {.lex_state = 642}, - [1612] = {.lex_state = 642}, - [1613] = {.lex_state = 642}, - [1614] = {.lex_state = 60}, - [1615] = {.lex_state = 642}, - [1616] = {.lex_state = 642}, - [1617] = {.lex_state = 642}, - [1618] = {.lex_state = 642}, - [1619] = {.lex_state = 36}, - [1620] = {.lex_state = 60}, - [1621] = {.lex_state = 36}, - [1622] = {.lex_state = 36}, - [1623] = {.lex_state = 36}, - [1624] = {.lex_state = 36}, - [1625] = {.lex_state = 642}, - [1626] = {.lex_state = 642}, - [1627] = {.lex_state = 36}, - [1628] = {.lex_state = 642}, - [1629] = {.lex_state = 642}, - [1630] = {.lex_state = 36}, - [1631] = {.lex_state = 642}, - [1632] = {.lex_state = 642}, - [1633] = {.lex_state = 642}, - [1634] = {.lex_state = 642}, - [1635] = {.lex_state = 642}, - [1636] = {.lex_state = 642}, - [1637] = {.lex_state = 642}, - [1638] = {.lex_state = 58}, - [1639] = {.lex_state = 36}, - [1640] = {.lex_state = 642}, - [1641] = {.lex_state = 60}, - [1642] = {.lex_state = 642}, - [1643] = {.lex_state = 58, .external_lex_state = 1}, - [1644] = {.lex_state = 642}, - [1645] = {.lex_state = 642}, - [1646] = {.lex_state = 642}, - [1647] = {.lex_state = 642}, - [1648] = {.lex_state = 36}, - [1649] = {.lex_state = 642}, - [1650] = {.lex_state = 642}, - [1651] = {.lex_state = 642}, - [1652] = {.lex_state = 36}, - [1653] = {.lex_state = 642}, - [1654] = {.lex_state = 642}, - [1655] = {.lex_state = 642}, - [1656] = {.lex_state = 642}, - [1657] = {.lex_state = 642}, - [1658] = {.lex_state = 642}, - [1659] = {.lex_state = 642}, - [1660] = {.lex_state = 642}, - [1661] = {.lex_state = 642}, - [1662] = {.lex_state = 36}, - [1663] = {.lex_state = 642}, - [1664] = {.lex_state = 642}, - [1665] = {.lex_state = 642}, - [1666] = {.lex_state = 642}, - [1667] = {.lex_state = 642}, - [1668] = {.lex_state = 36}, - [1669] = {.lex_state = 642}, - [1670] = {.lex_state = 642}, - [1671] = {.lex_state = 642}, - [1672] = {.lex_state = 36}, - [1673] = {.lex_state = 642}, - [1674] = {.lex_state = 642}, - [1675] = {.lex_state = 642}, - [1676] = {.lex_state = 642}, - [1677] = {.lex_state = 642}, - [1678] = {.lex_state = 642}, - [1679] = {.lex_state = 642}, - [1680] = {.lex_state = 642}, - [1681] = {.lex_state = 642}, - [1682] = {.lex_state = 36}, - [1683] = {.lex_state = 36}, - [1684] = {.lex_state = 60}, - [1685] = {.lex_state = 642}, - [1686] = {.lex_state = 642}, - [1687] = {.lex_state = 60, .external_lex_state = 1}, - [1688] = {.lex_state = 60}, - [1689] = {.lex_state = 36}, - [1690] = {.lex_state = 642}, - [1691] = {.lex_state = 642}, - [1692] = {.lex_state = 642}, - [1693] = {.lex_state = 642}, - [1694] = {.lex_state = 58}, - [1695] = {.lex_state = 50}, - [1696] = {.lex_state = 50}, - [1697] = {.lex_state = 642}, - [1698] = {.lex_state = 642}, + [835] = {.lex_state = 734}, + [836] = {.lex_state = 734}, + [837] = {.lex_state = 734}, + [838] = {.lex_state = 734}, + [839] = {.lex_state = 734}, + [840] = {.lex_state = 734}, + [841] = {.lex_state = 734}, + [842] = {.lex_state = 734}, + [843] = {.lex_state = 734}, + [844] = {.lex_state = 734}, + [845] = {.lex_state = 734}, + [846] = {.lex_state = 734}, + [847] = {.lex_state = 734}, + [848] = {.lex_state = 734}, + [849] = {.lex_state = 734}, + [850] = {.lex_state = 734}, + [851] = {.lex_state = 734}, + [852] = {.lex_state = 734}, + [853] = {.lex_state = 734}, + [854] = {.lex_state = 734}, + [855] = {.lex_state = 734}, + [856] = {.lex_state = 38, .external_lex_state = 1}, + [857] = {.lex_state = 40, .external_lex_state = 1}, + [858] = {.lex_state = 38}, + [859] = {.lex_state = 40}, + [860] = {.lex_state = 40}, + [861] = {.lex_state = 38}, + [862] = {.lex_state = 38}, + [863] = {.lex_state = 40}, + [864] = {.lex_state = 40, .external_lex_state = 1}, + [865] = {.lex_state = 735}, + [866] = {.lex_state = 38}, + [867] = {.lex_state = 735}, + [868] = {.lex_state = 40, .external_lex_state = 1}, + [869] = {.lex_state = 38}, + [870] = {.lex_state = 98}, + [871] = {.lex_state = 38}, + [872] = {.lex_state = 38}, + [873] = {.lex_state = 38}, + [874] = {.lex_state = 38}, + [875] = {.lex_state = 38}, + [876] = {.lex_state = 38}, + [877] = {.lex_state = 38}, + [878] = {.lex_state = 38}, + [879] = {.lex_state = 38}, + [880] = {.lex_state = 38}, + [881] = {.lex_state = 98}, + [882] = {.lex_state = 38}, + [883] = {.lex_state = 735}, + [884] = {.lex_state = 38}, + [885] = {.lex_state = 38}, + [886] = {.lex_state = 38}, + [887] = {.lex_state = 38}, + [888] = {.lex_state = 38}, + [889] = {.lex_state = 38}, + [890] = {.lex_state = 38}, + [891] = {.lex_state = 38}, + [892] = {.lex_state = 38}, + [893] = {.lex_state = 38}, + [894] = {.lex_state = 98}, + [895] = {.lex_state = 38}, + [896] = {.lex_state = 38}, + [897] = {.lex_state = 40}, + [898] = {.lex_state = 40}, + [899] = {.lex_state = 38}, + [900] = {.lex_state = 38}, + [901] = {.lex_state = 38}, + [902] = {.lex_state = 40}, + [903] = {.lex_state = 40}, + [904] = {.lex_state = 40}, + [905] = {.lex_state = 40}, + [906] = {.lex_state = 40}, + [907] = {.lex_state = 40}, + [908] = {.lex_state = 40}, + [909] = {.lex_state = 40}, + [910] = {.lex_state = 40}, + [911] = {.lex_state = 40}, + [912] = {.lex_state = 40}, + [913] = {.lex_state = 40}, + [914] = {.lex_state = 40}, + [915] = {.lex_state = 40}, + [916] = {.lex_state = 40}, + [917] = {.lex_state = 40}, + [918] = {.lex_state = 40}, + [919] = {.lex_state = 40}, + [920] = {.lex_state = 40}, + [921] = {.lex_state = 40}, + [922] = {.lex_state = 40}, + [923] = {.lex_state = 40}, + [924] = {.lex_state = 40}, + [925] = {.lex_state = 40}, + [926] = {.lex_state = 40}, + [927] = {.lex_state = 40}, + [928] = {.lex_state = 40}, + [929] = {.lex_state = 40}, + [930] = {.lex_state = 40}, + [931] = {.lex_state = 40}, + [932] = {.lex_state = 98}, + [933] = {.lex_state = 734, .external_lex_state = 1}, + [934] = {.lex_state = 98}, + [935] = {.lex_state = 98}, + [936] = {.lex_state = 98}, + [937] = {.lex_state = 735}, + [938] = {.lex_state = 735}, + [939] = {.lex_state = 735}, + [940] = {.lex_state = 735}, + [941] = {.lex_state = 98}, + [942] = {.lex_state = 98}, + [943] = {.lex_state = 98}, + [944] = {.lex_state = 735}, + [945] = {.lex_state = 735}, + [946] = {.lex_state = 735}, + [947] = {.lex_state = 735}, + [948] = {.lex_state = 735}, + [949] = {.lex_state = 735}, + [950] = {.lex_state = 735}, + [951] = {.lex_state = 735}, + [952] = {.lex_state = 735}, + [953] = {.lex_state = 735}, + [954] = {.lex_state = 735}, + [955] = {.lex_state = 735}, + [956] = {.lex_state = 735}, + [957] = {.lex_state = 735}, + [958] = {.lex_state = 735}, + [959] = {.lex_state = 735}, + [960] = {.lex_state = 735}, + [961] = {.lex_state = 735}, + [962] = {.lex_state = 735}, + [963] = {.lex_state = 735}, + [964] = {.lex_state = 735}, + [965] = {.lex_state = 735}, + [966] = {.lex_state = 735}, + [967] = {.lex_state = 735}, + [968] = {.lex_state = 735}, + [969] = {.lex_state = 735}, + [970] = {.lex_state = 735}, + [971] = {.lex_state = 735}, + [972] = {.lex_state = 735}, + [973] = {.lex_state = 734, .external_lex_state = 1}, + [974] = {.lex_state = 735}, + [975] = {.lex_state = 735}, + [976] = {.lex_state = 735}, + [977] = {.lex_state = 735}, + [978] = {.lex_state = 735}, + [979] = {.lex_state = 735}, + [980] = {.lex_state = 735}, + [981] = {.lex_state = 734, .external_lex_state = 1}, + [982] = {.lex_state = 735}, + [983] = {.lex_state = 735}, + [984] = {.lex_state = 735}, + [985] = {.lex_state = 735}, + [986] = {.lex_state = 735}, + [987] = {.lex_state = 735}, + [988] = {.lex_state = 735}, + [989] = {.lex_state = 735}, + [990] = {.lex_state = 735}, + [991] = {.lex_state = 735}, + [992] = {.lex_state = 735}, + [993] = {.lex_state = 735}, + [994] = {.lex_state = 735}, + [995] = {.lex_state = 735}, + [996] = {.lex_state = 735}, + [997] = {.lex_state = 735}, + [998] = {.lex_state = 735}, + [999] = {.lex_state = 735}, + [1000] = {.lex_state = 735}, + [1001] = {.lex_state = 735}, + [1002] = {.lex_state = 735}, + [1003] = {.lex_state = 735}, + [1004] = {.lex_state = 735}, + [1005] = {.lex_state = 735}, + [1006] = {.lex_state = 735}, + [1007] = {.lex_state = 735}, + [1008] = {.lex_state = 735}, + [1009] = {.lex_state = 735}, + [1010] = {.lex_state = 735}, + [1011] = {.lex_state = 735}, + [1012] = {.lex_state = 734, .external_lex_state = 1}, + [1013] = {.lex_state = 735}, + [1014] = {.lex_state = 735}, + [1015] = {.lex_state = 735}, + [1016] = {.lex_state = 735}, + [1017] = {.lex_state = 98}, + [1018] = {.lex_state = 98}, + [1019] = {.lex_state = 98}, + [1020] = {.lex_state = 98}, + [1021] = {.lex_state = 734, .external_lex_state = 1}, + [1022] = {.lex_state = 735}, + [1023] = {.lex_state = 98}, + [1024] = {.lex_state = 98}, + [1025] = {.lex_state = 98}, + [1026] = {.lex_state = 98}, + [1027] = {.lex_state = 98}, + [1028] = {.lex_state = 98}, + [1029] = {.lex_state = 98}, + [1030] = {.lex_state = 98}, + [1031] = {.lex_state = 98}, + [1032] = {.lex_state = 98}, + [1033] = {.lex_state = 98}, + [1034] = {.lex_state = 98}, + [1035] = {.lex_state = 98}, + [1036] = {.lex_state = 98}, + [1037] = {.lex_state = 98}, + [1038] = {.lex_state = 98}, + [1039] = {.lex_state = 98}, + [1040] = {.lex_state = 98}, + [1041] = {.lex_state = 98}, + [1042] = {.lex_state = 98}, + [1043] = {.lex_state = 98}, + [1044] = {.lex_state = 98}, + [1045] = {.lex_state = 98}, + [1046] = {.lex_state = 98}, + [1047] = {.lex_state = 98}, + [1048] = {.lex_state = 98}, + [1049] = {.lex_state = 734, .external_lex_state = 1}, + [1050] = {.lex_state = 98}, + [1051] = {.lex_state = 98}, + [1052] = {.lex_state = 98}, + [1053] = {.lex_state = 98}, + [1054] = {.lex_state = 98}, + [1055] = {.lex_state = 98}, + [1056] = {.lex_state = 734, .external_lex_state = 1}, + [1057] = {.lex_state = 98}, + [1058] = {.lex_state = 98}, + [1059] = {.lex_state = 98}, + [1060] = {.lex_state = 98}, + [1061] = {.lex_state = 98}, + [1062] = {.lex_state = 98}, + [1063] = {.lex_state = 98}, + [1064] = {.lex_state = 98}, + [1065] = {.lex_state = 98}, + [1066] = {.lex_state = 98}, + [1067] = {.lex_state = 98}, + [1068] = {.lex_state = 98}, + [1069] = {.lex_state = 98}, + [1070] = {.lex_state = 98}, + [1071] = {.lex_state = 98}, + [1072] = {.lex_state = 98}, + [1073] = {.lex_state = 98}, + [1074] = {.lex_state = 98}, + [1075] = {.lex_state = 98}, + [1076] = {.lex_state = 98}, + [1077] = {.lex_state = 98}, + [1078] = {.lex_state = 98}, + [1079] = {.lex_state = 98}, + [1080] = {.lex_state = 98}, + [1081] = {.lex_state = 98}, + [1082] = {.lex_state = 98}, + [1083] = {.lex_state = 98}, + [1084] = {.lex_state = 734, .external_lex_state = 1}, + [1085] = {.lex_state = 98}, + [1086] = {.lex_state = 98}, + [1087] = {.lex_state = 98}, + [1088] = {.lex_state = 98}, + [1089] = {.lex_state = 98}, + [1090] = {.lex_state = 98}, + [1091] = {.lex_state = 98}, + [1092] = {.lex_state = 98}, + [1093] = {.lex_state = 98}, + [1094] = {.lex_state = 98}, + [1095] = {.lex_state = 735}, + [1096] = {.lex_state = 734, .external_lex_state = 1}, + [1097] = {.lex_state = 735}, + [1098] = {.lex_state = 734, .external_lex_state = 1}, + [1099] = {.lex_state = 735}, + [1100] = {.lex_state = 735}, + [1101] = {.lex_state = 735}, + [1102] = {.lex_state = 99}, + [1103] = {.lex_state = 736}, + [1104] = {.lex_state = 736}, + [1105] = {.lex_state = 736}, + [1106] = {.lex_state = 736}, + [1107] = {.lex_state = 99}, + [1108] = {.lex_state = 99}, + [1109] = {.lex_state = 736}, + [1110] = {.lex_state = 736}, + [1111] = {.lex_state = 736}, + [1112] = {.lex_state = 736}, + [1113] = {.lex_state = 736}, + [1114] = {.lex_state = 736}, + [1115] = {.lex_state = 99}, + [1116] = {.lex_state = 99}, + [1117] = {.lex_state = 99}, + [1118] = {.lex_state = 99}, + [1119] = {.lex_state = 99}, + [1120] = {.lex_state = 736}, + [1121] = {.lex_state = 99}, + [1122] = {.lex_state = 99}, + [1123] = {.lex_state = 736}, + [1124] = {.lex_state = 736}, + [1125] = {.lex_state = 736}, + [1126] = {.lex_state = 99}, + [1127] = {.lex_state = 99}, + [1128] = {.lex_state = 736}, + [1129] = {.lex_state = 99}, + [1130] = {.lex_state = 736}, + [1131] = {.lex_state = 736}, + [1132] = {.lex_state = 99}, + [1133] = {.lex_state = 736}, + [1134] = {.lex_state = 736}, + [1135] = {.lex_state = 736}, + [1136] = {.lex_state = 99}, + [1137] = {.lex_state = 736}, + [1138] = {.lex_state = 99}, + [1139] = {.lex_state = 99}, + [1140] = {.lex_state = 736}, + [1141] = {.lex_state = 736}, + [1142] = {.lex_state = 736}, + [1143] = {.lex_state = 99}, + [1144] = {.lex_state = 736}, + [1145] = {.lex_state = 736}, + [1146] = {.lex_state = 99}, + [1147] = {.lex_state = 99}, + [1148] = {.lex_state = 99}, + [1149] = {.lex_state = 99}, + [1150] = {.lex_state = 736}, + [1151] = {.lex_state = 736}, + [1152] = {.lex_state = 736}, + [1153] = {.lex_state = 99}, + [1154] = {.lex_state = 736}, + [1155] = {.lex_state = 736}, + [1156] = {.lex_state = 99}, + [1157] = {.lex_state = 736}, + [1158] = {.lex_state = 736}, + [1159] = {.lex_state = 99}, + [1160] = {.lex_state = 99}, + [1161] = {.lex_state = 107}, + [1162] = {.lex_state = 99}, + [1163] = {.lex_state = 736}, + [1164] = {.lex_state = 736}, + [1165] = {.lex_state = 736}, + [1166] = {.lex_state = 736}, + [1167] = {.lex_state = 736}, + [1168] = {.lex_state = 99}, + [1169] = {.lex_state = 736}, + [1170] = {.lex_state = 736}, + [1171] = {.lex_state = 736}, + [1172] = {.lex_state = 736}, + [1173] = {.lex_state = 99}, + [1174] = {.lex_state = 736}, + [1175] = {.lex_state = 736}, + [1176] = {.lex_state = 736}, + [1177] = {.lex_state = 99}, + [1178] = {.lex_state = 736}, + [1179] = {.lex_state = 736}, + [1180] = {.lex_state = 736}, + [1181] = {.lex_state = 736}, + [1182] = {.lex_state = 99}, + [1183] = {.lex_state = 99}, + [1184] = {.lex_state = 736}, + [1185] = {.lex_state = 99}, + [1186] = {.lex_state = 736}, + [1187] = {.lex_state = 736}, + [1188] = {.lex_state = 99}, + [1189] = {.lex_state = 99}, + [1190] = {.lex_state = 736}, + [1191] = {.lex_state = 99}, + [1192] = {.lex_state = 99}, + [1193] = {.lex_state = 736}, + [1194] = {.lex_state = 99}, + [1195] = {.lex_state = 736}, + [1196] = {.lex_state = 736}, + [1197] = {.lex_state = 99}, + [1198] = {.lex_state = 736}, + [1199] = {.lex_state = 99}, + [1200] = {.lex_state = 99}, + [1201] = {.lex_state = 736}, + [1202] = {.lex_state = 736}, + [1203] = {.lex_state = 99}, + [1204] = {.lex_state = 99}, + [1205] = {.lex_state = 736}, + [1206] = {.lex_state = 736}, + [1207] = {.lex_state = 736}, + [1208] = {.lex_state = 736}, + [1209] = {.lex_state = 736}, + [1210] = {.lex_state = 736}, + [1211] = {.lex_state = 736}, + [1212] = {.lex_state = 736}, + [1213] = {.lex_state = 736}, + [1214] = {.lex_state = 99}, + [1215] = {.lex_state = 99}, + [1216] = {.lex_state = 736}, + [1217] = {.lex_state = 736}, + [1218] = {.lex_state = 736}, + [1219] = {.lex_state = 736}, + [1220] = {.lex_state = 736}, + [1221] = {.lex_state = 736}, + [1222] = {.lex_state = 99}, + [1223] = {.lex_state = 736}, + [1224] = {.lex_state = 736}, + [1225] = {.lex_state = 736}, + [1226] = {.lex_state = 99}, + [1227] = {.lex_state = 99}, + [1228] = {.lex_state = 99}, + [1229] = {.lex_state = 99}, + [1230] = {.lex_state = 99}, + [1231] = {.lex_state = 736}, + [1232] = {.lex_state = 99}, + [1233] = {.lex_state = 736}, + [1234] = {.lex_state = 736}, + [1235] = {.lex_state = 736}, + [1236] = {.lex_state = 736}, + [1237] = {.lex_state = 736}, + [1238] = {.lex_state = 736}, + [1239] = {.lex_state = 99}, + [1240] = {.lex_state = 736}, + [1241] = {.lex_state = 736}, + [1242] = {.lex_state = 736}, + [1243] = {.lex_state = 736}, + [1244] = {.lex_state = 99}, + [1245] = {.lex_state = 736}, + [1246] = {.lex_state = 736}, + [1247] = {.lex_state = 736}, + [1248] = {.lex_state = 99}, + [1249] = {.lex_state = 99}, + [1250] = {.lex_state = 736}, + [1251] = {.lex_state = 736}, + [1252] = {.lex_state = 99}, + [1253] = {.lex_state = 99}, + [1254] = {.lex_state = 99}, + [1255] = {.lex_state = 99}, + [1256] = {.lex_state = 99}, + [1257] = {.lex_state = 736}, + [1258] = {.lex_state = 736}, + [1259] = {.lex_state = 99}, + [1260] = {.lex_state = 99}, + [1261] = {.lex_state = 736}, + [1262] = {.lex_state = 736}, + [1263] = {.lex_state = 99}, + [1264] = {.lex_state = 736}, + [1265] = {.lex_state = 736}, + [1266] = {.lex_state = 99}, + [1267] = {.lex_state = 99}, + [1268] = {.lex_state = 736}, + [1269] = {.lex_state = 99}, + [1270] = {.lex_state = 99}, + [1271] = {.lex_state = 99}, + [1272] = {.lex_state = 736}, + [1273] = {.lex_state = 736}, + [1274] = {.lex_state = 99}, + [1275] = {.lex_state = 99}, + [1276] = {.lex_state = 99}, + [1277] = {.lex_state = 99}, + [1278] = {.lex_state = 99}, + [1279] = {.lex_state = 99}, + [1280] = {.lex_state = 736}, + [1281] = {.lex_state = 99}, + [1282] = {.lex_state = 99}, + [1283] = {.lex_state = 736}, + [1284] = {.lex_state = 99}, + [1285] = {.lex_state = 99}, + [1286] = {.lex_state = 99}, + [1287] = {.lex_state = 99}, + [1288] = {.lex_state = 99}, + [1289] = {.lex_state = 99}, + [1290] = {.lex_state = 99}, + [1291] = {.lex_state = 99}, + [1292] = {.lex_state = 99}, + [1293] = {.lex_state = 736}, + [1294] = {.lex_state = 99}, + [1295] = {.lex_state = 736}, + [1296] = {.lex_state = 99}, + [1297] = {.lex_state = 99}, + [1298] = {.lex_state = 736}, + [1299] = {.lex_state = 736}, + [1300] = {.lex_state = 736}, + [1301] = {.lex_state = 736}, + [1302] = {.lex_state = 99}, + [1303] = {.lex_state = 736}, + [1304] = {.lex_state = 99}, + [1305] = {.lex_state = 99}, + [1306] = {.lex_state = 736}, + [1307] = {.lex_state = 736}, + [1308] = {.lex_state = 99}, + [1309] = {.lex_state = 99}, + [1310] = {.lex_state = 99}, + [1311] = {.lex_state = 99}, + [1312] = {.lex_state = 99}, + [1313] = {.lex_state = 99}, + [1314] = {.lex_state = 99}, + [1315] = {.lex_state = 99}, + [1316] = {.lex_state = 99}, + [1317] = {.lex_state = 99}, + [1318] = {.lex_state = 734, .external_lex_state = 1}, + [1319] = {.lex_state = 99}, + [1320] = {.lex_state = 736}, + [1321] = {.lex_state = 99}, + [1322] = {.lex_state = 99}, + [1323] = {.lex_state = 99}, + [1324] = {.lex_state = 736}, + [1325] = {.lex_state = 736}, + [1326] = {.lex_state = 99}, + [1327] = {.lex_state = 736}, + [1328] = {.lex_state = 736}, + [1329] = {.lex_state = 99}, + [1330] = {.lex_state = 736}, + [1331] = {.lex_state = 736}, + [1332] = {.lex_state = 736}, + [1333] = {.lex_state = 99}, + [1334] = {.lex_state = 99}, + [1335] = {.lex_state = 736}, + [1336] = {.lex_state = 99}, + [1337] = {.lex_state = 736}, + [1338] = {.lex_state = 736}, + [1339] = {.lex_state = 736}, + [1340] = {.lex_state = 736}, + [1341] = {.lex_state = 736}, + [1342] = {.lex_state = 736}, + [1343] = {.lex_state = 99}, + [1344] = {.lex_state = 736}, + [1345] = {.lex_state = 99}, + [1346] = {.lex_state = 736}, + [1347] = {.lex_state = 99}, + [1348] = {.lex_state = 99}, + [1349] = {.lex_state = 736}, + [1350] = {.lex_state = 736}, + [1351] = {.lex_state = 736}, + [1352] = {.lex_state = 736}, + [1353] = {.lex_state = 99}, + [1354] = {.lex_state = 99}, + [1355] = {.lex_state = 736}, + [1356] = {.lex_state = 736}, + [1357] = {.lex_state = 736}, + [1358] = {.lex_state = 99}, + [1359] = {.lex_state = 99}, + [1360] = {.lex_state = 736}, + [1361] = {.lex_state = 99}, + [1362] = {.lex_state = 99}, + [1363] = {.lex_state = 99}, + [1364] = {.lex_state = 99}, + [1365] = {.lex_state = 99}, + [1366] = {.lex_state = 736}, + [1367] = {.lex_state = 99}, + [1368] = {.lex_state = 99}, + [1369] = {.lex_state = 99}, + [1370] = {.lex_state = 736}, + [1371] = {.lex_state = 736}, + [1372] = {.lex_state = 99}, + [1373] = {.lex_state = 736}, + [1374] = {.lex_state = 736}, + [1375] = {.lex_state = 736}, + [1376] = {.lex_state = 736}, + [1377] = {.lex_state = 99}, + [1378] = {.lex_state = 736}, + [1379] = {.lex_state = 99}, + [1380] = {.lex_state = 736}, + [1381] = {.lex_state = 736}, + [1382] = {.lex_state = 99}, + [1383] = {.lex_state = 99}, + [1384] = {.lex_state = 99}, + [1385] = {.lex_state = 736}, + [1386] = {.lex_state = 99}, + [1387] = {.lex_state = 99}, + [1388] = {.lex_state = 99}, + [1389] = {.lex_state = 99}, + [1390] = {.lex_state = 99}, + [1391] = {.lex_state = 99}, + [1392] = {.lex_state = 99}, + [1393] = {.lex_state = 99}, + [1394] = {.lex_state = 99}, + [1395] = {.lex_state = 99}, + [1396] = {.lex_state = 736}, + [1397] = {.lex_state = 736}, + [1398] = {.lex_state = 99}, + [1399] = {.lex_state = 99}, + [1400] = {.lex_state = 99}, + [1401] = {.lex_state = 99}, + [1402] = {.lex_state = 99}, + [1403] = {.lex_state = 736}, + [1404] = {.lex_state = 99}, + [1405] = {.lex_state = 736}, + [1406] = {.lex_state = 99}, + [1407] = {.lex_state = 99}, + [1408] = {.lex_state = 99}, + [1409] = {.lex_state = 99}, + [1410] = {.lex_state = 99}, + [1411] = {.lex_state = 736}, + [1412] = {.lex_state = 736}, + [1413] = {.lex_state = 99}, + [1414] = {.lex_state = 736}, + [1415] = {.lex_state = 99}, + [1416] = {.lex_state = 736}, + [1417] = {.lex_state = 736}, + [1418] = {.lex_state = 99}, + [1419] = {.lex_state = 99}, + [1420] = {.lex_state = 99}, + [1421] = {.lex_state = 736}, + [1422] = {.lex_state = 99}, + [1423] = {.lex_state = 736}, + [1424] = {.lex_state = 736}, + [1425] = {.lex_state = 736}, + [1426] = {.lex_state = 736}, + [1427] = {.lex_state = 736}, + [1428] = {.lex_state = 736}, + [1429] = {.lex_state = 736}, + [1430] = {.lex_state = 736}, + [1431] = {.lex_state = 736}, + [1432] = {.lex_state = 736}, + [1433] = {.lex_state = 99}, + [1434] = {.lex_state = 99}, + [1435] = {.lex_state = 99}, + [1436] = {.lex_state = 99}, + [1437] = {.lex_state = 99}, + [1438] = {.lex_state = 99}, + [1439] = {.lex_state = 99}, + [1440] = {.lex_state = 99}, + [1441] = {.lex_state = 99}, + [1442] = {.lex_state = 99}, + [1443] = {.lex_state = 736}, + [1444] = {.lex_state = 99}, + [1445] = {.lex_state = 736}, + [1446] = {.lex_state = 99}, + [1447] = {.lex_state = 736}, + [1448] = {.lex_state = 99}, + [1449] = {.lex_state = 99}, + [1450] = {.lex_state = 736}, + [1451] = {.lex_state = 736}, + [1452] = {.lex_state = 99}, + [1453] = {.lex_state = 736}, + [1454] = {.lex_state = 99}, + [1455] = {.lex_state = 736}, + [1456] = {.lex_state = 736}, + [1457] = {.lex_state = 736}, + [1458] = {.lex_state = 736}, + [1459] = {.lex_state = 99}, + [1460] = {.lex_state = 99}, + [1461] = {.lex_state = 99}, + [1462] = {.lex_state = 99}, + [1463] = {.lex_state = 736}, + [1464] = {.lex_state = 736}, + [1465] = {.lex_state = 736}, + [1466] = {.lex_state = 736}, + [1467] = {.lex_state = 99}, + [1468] = {.lex_state = 99}, + [1469] = {.lex_state = 99}, + [1470] = {.lex_state = 99}, + [1471] = {.lex_state = 99}, + [1472] = {.lex_state = 736}, + [1473] = {.lex_state = 736}, + [1474] = {.lex_state = 99}, + [1475] = {.lex_state = 736}, + [1476] = {.lex_state = 734}, + [1477] = {.lex_state = 58}, + [1478] = {.lex_state = 734}, + [1479] = {.lex_state = 734}, + [1480] = {.lex_state = 58}, + [1481] = {.lex_state = 734}, + [1482] = {.lex_state = 734}, + [1483] = {.lex_state = 734}, + [1484] = {.lex_state = 734}, + [1485] = {.lex_state = 734}, + [1486] = {.lex_state = 734}, + [1487] = {.lex_state = 734}, + [1488] = {.lex_state = 734}, + [1489] = {.lex_state = 734}, + [1490] = {.lex_state = 734}, + [1491] = {.lex_state = 734}, + [1492] = {.lex_state = 54}, + [1493] = {.lex_state = 734}, + [1494] = {.lex_state = 734}, + [1495] = {.lex_state = 58}, + [1496] = {.lex_state = 734}, + [1497] = {.lex_state = 734}, + [1498] = {.lex_state = 734}, + [1499] = {.lex_state = 734}, + [1500] = {.lex_state = 54}, + [1501] = {.lex_state = 54}, + [1502] = {.lex_state = 734}, + [1503] = {.lex_state = 54}, + [1504] = {.lex_state = 54}, + [1505] = {.lex_state = 109}, + [1506] = {.lex_state = 734}, + [1507] = {.lex_state = 734}, + [1508] = {.lex_state = 109}, + [1509] = {.lex_state = 58}, + [1510] = {.lex_state = 734}, + [1511] = {.lex_state = 109}, + [1512] = {.lex_state = 734}, + [1513] = {.lex_state = 109}, + [1514] = {.lex_state = 109}, + [1515] = {.lex_state = 109}, + [1516] = {.lex_state = 109}, + [1517] = {.lex_state = 734}, + [1518] = {.lex_state = 109}, + [1519] = {.lex_state = 734}, + [1520] = {.lex_state = 734}, + [1521] = {.lex_state = 58}, + [1522] = {.lex_state = 109}, + [1523] = {.lex_state = 734}, + [1524] = {.lex_state = 109}, + [1525] = {.lex_state = 109}, + [1526] = {.lex_state = 109}, + [1527] = {.lex_state = 734}, + [1528] = {.lex_state = 734}, + [1529] = {.lex_state = 734}, + [1530] = {.lex_state = 109}, + [1531] = {.lex_state = 109}, + [1532] = {.lex_state = 109}, + [1533] = {.lex_state = 734}, + [1534] = {.lex_state = 734}, + [1535] = {.lex_state = 734}, + [1536] = {.lex_state = 734}, + [1537] = {.lex_state = 734}, + [1538] = {.lex_state = 109}, + [1539] = {.lex_state = 109}, + [1540] = {.lex_state = 734}, + [1541] = {.lex_state = 734}, + [1542] = {.lex_state = 734}, + [1543] = {.lex_state = 734}, + [1544] = {.lex_state = 734}, + [1545] = {.lex_state = 734}, + [1546] = {.lex_state = 734}, + [1547] = {.lex_state = 58}, + [1548] = {.lex_state = 58}, + [1549] = {.lex_state = 734}, + [1550] = {.lex_state = 734}, + [1551] = {.lex_state = 734}, + [1552] = {.lex_state = 734}, + [1553] = {.lex_state = 734}, + [1554] = {.lex_state = 734}, + [1555] = {.lex_state = 734}, + [1556] = {.lex_state = 734}, + [1557] = {.lex_state = 734}, + [1558] = {.lex_state = 734}, + [1559] = {.lex_state = 734}, + [1560] = {.lex_state = 734}, + [1561] = {.lex_state = 734}, + [1562] = {.lex_state = 734}, + [1563] = {.lex_state = 734}, + [1564] = {.lex_state = 734}, + [1565] = {.lex_state = 734}, + [1566] = {.lex_state = 734}, + [1567] = {.lex_state = 734}, + [1568] = {.lex_state = 734}, + [1569] = {.lex_state = 734}, + [1570] = {.lex_state = 109}, + [1571] = {.lex_state = 734}, + [1572] = {.lex_state = 734}, + [1573] = {.lex_state = 734}, + [1574] = {.lex_state = 734}, + [1575] = {.lex_state = 734}, + [1576] = {.lex_state = 734}, + [1577] = {.lex_state = 734}, + [1578] = {.lex_state = 734}, + [1579] = {.lex_state = 734}, + [1580] = {.lex_state = 734}, + [1581] = {.lex_state = 734}, + [1582] = {.lex_state = 734}, + [1583] = {.lex_state = 734}, + [1584] = {.lex_state = 734}, + [1585] = {.lex_state = 734}, + [1586] = {.lex_state = 734}, + [1587] = {.lex_state = 734}, + [1588] = {.lex_state = 734}, + [1589] = {.lex_state = 734}, + [1590] = {.lex_state = 734}, + [1591] = {.lex_state = 734}, + [1592] = {.lex_state = 734}, + [1593] = {.lex_state = 734}, + [1594] = {.lex_state = 734}, + [1595] = {.lex_state = 734}, + [1596] = {.lex_state = 734}, + [1597] = {.lex_state = 734}, + [1598] = {.lex_state = 734}, + [1599] = {.lex_state = 734}, + [1600] = {.lex_state = 734}, + [1601] = {.lex_state = 734}, + [1602] = {.lex_state = 734}, + [1603] = {.lex_state = 734}, + [1604] = {.lex_state = 734}, + [1605] = {.lex_state = 734}, + [1606] = {.lex_state = 734}, + [1607] = {.lex_state = 734}, + [1608] = {.lex_state = 734}, + [1609] = {.lex_state = 734}, + [1610] = {.lex_state = 102}, + [1611] = {.lex_state = 734}, + [1612] = {.lex_state = 734}, + [1613] = {.lex_state = 734}, + [1614] = {.lex_state = 734}, + [1615] = {.lex_state = 734}, + [1616] = {.lex_state = 734}, + [1617] = {.lex_state = 734}, + [1618] = {.lex_state = 734}, + [1619] = {.lex_state = 734}, + [1620] = {.lex_state = 102}, + [1621] = {.lex_state = 734}, + [1622] = {.lex_state = 734}, + [1623] = {.lex_state = 734}, + [1624] = {.lex_state = 102}, + [1625] = {.lex_state = 734, .external_lex_state = 1}, + [1626] = {.lex_state = 102}, + [1627] = {.lex_state = 734}, + [1628] = {.lex_state = 102}, + [1629] = {.lex_state = 58}, + [1630] = {.lex_state = 734}, + [1631] = {.lex_state = 734}, + [1632] = {.lex_state = 102}, + [1633] = {.lex_state = 734}, + [1634] = {.lex_state = 734}, + [1635] = {.lex_state = 58, .external_lex_state = 1}, + [1636] = {.lex_state = 58, .external_lex_state = 1}, + [1637] = {.lex_state = 102}, + [1638] = {.lex_state = 102}, + [1639] = {.lex_state = 58, .external_lex_state = 1}, + [1640] = {.lex_state = 58, .external_lex_state = 1}, + [1641] = {.lex_state = 734, .external_lex_state = 1}, + [1642] = {.lex_state = 734}, + [1643] = {.lex_state = 58}, + [1644] = {.lex_state = 734}, + [1645] = {.lex_state = 58}, + [1646] = {.lex_state = 734, .external_lex_state = 1}, + [1647] = {.lex_state = 734, .external_lex_state = 1}, + [1648] = {.lex_state = 734, .external_lex_state = 1}, + [1649] = {.lex_state = 734}, + [1650] = {.lex_state = 58}, + [1651] = {.lex_state = 734, .external_lex_state = 1}, + [1652] = {.lex_state = 734, .external_lex_state = 1}, + [1653] = {.lex_state = 734}, + [1654] = {.lex_state = 58}, + [1655] = {.lex_state = 734}, + [1656] = {.lex_state = 734}, + [1657] = {.lex_state = 96}, + [1658] = {.lex_state = 734}, + [1659] = {.lex_state = 734}, + [1660] = {.lex_state = 734}, + [1661] = {.lex_state = 734}, + [1662] = {.lex_state = 58}, + [1663] = {.lex_state = 58}, + [1664] = {.lex_state = 734}, + [1665] = {.lex_state = 58}, + [1666] = {.lex_state = 734}, + [1667] = {.lex_state = 734}, + [1668] = {.lex_state = 58}, + [1669] = {.lex_state = 734}, + [1670] = {.lex_state = 734}, + [1671] = {.lex_state = 734}, + [1672] = {.lex_state = 734}, + [1673] = {.lex_state = 734}, + [1674] = {.lex_state = 734}, + [1675] = {.lex_state = 58}, + [1676] = {.lex_state = 734}, + [1677] = {.lex_state = 734}, + [1678] = {.lex_state = 58}, + [1679] = {.lex_state = 734}, + [1680] = {.lex_state = 734}, + [1681] = {.lex_state = 734}, + [1682] = {.lex_state = 734}, + [1683] = {.lex_state = 734}, + [1684] = {.lex_state = 734}, + [1685] = {.lex_state = 734}, + [1686] = {.lex_state = 58}, + [1687] = {.lex_state = 96}, + [1688] = {.lex_state = 58}, + [1689] = {.lex_state = 96}, + [1690] = {.lex_state = 96}, + [1691] = {.lex_state = 58}, + [1692] = {.lex_state = 58}, + [1693] = {.lex_state = 59, .external_lex_state = 1}, + [1694] = {.lex_state = 734}, + [1695] = {.lex_state = 58}, + [1696] = {.lex_state = 734}, + [1697] = {.lex_state = 58}, + [1698] = {.lex_state = 58}, [1699] = {.lex_state = 58}, - [1700] = {.lex_state = 50}, - [1701] = {.lex_state = 50}, - [1702] = {.lex_state = 59, .external_lex_state = 1}, + [1700] = {.lex_state = 734}, + [1701] = {.lex_state = 58}, + [1702] = {.lex_state = 734}, [1703] = {.lex_state = 58}, - [1704] = {.lex_state = 90}, - [1705] = {.lex_state = 642}, - [1706] = {.lex_state = 59, .external_lex_state = 1}, - [1707] = {.lex_state = 50}, - [1708] = {.lex_state = 642}, - [1709] = {.lex_state = 642}, - [1710] = {.lex_state = 60, .external_lex_state = 1}, + [1704] = {.lex_state = 734}, + [1705] = {.lex_state = 734}, + [1706] = {.lex_state = 734}, + [1707] = {.lex_state = 734}, + [1708] = {.lex_state = 58}, + [1709] = {.lex_state = 734}, + [1710] = {.lex_state = 734}, [1711] = {.lex_state = 58}, [1712] = {.lex_state = 58}, - [1713] = {.lex_state = 50}, - [1714] = {.lex_state = 90}, - [1715] = {.lex_state = 36}, - [1716] = {.lex_state = 642}, - [1717] = {.lex_state = 60}, - [1718] = {.lex_state = 60, .external_lex_state = 1}, - [1719] = {.lex_state = 36}, - [1720] = {.lex_state = 36}, - [1721] = {.lex_state = 36}, - [1722] = {.lex_state = 36}, - [1723] = {.lex_state = 60}, - [1724] = {.lex_state = 59, .external_lex_state = 1}, - [1725] = {.lex_state = 36}, - [1726] = {.lex_state = 642}, - [1727] = {.lex_state = 642}, - [1728] = {.lex_state = 642}, - [1729] = {.lex_state = 59}, - [1730] = {.lex_state = 642}, - [1731] = {.lex_state = 36}, - [1732] = {.lex_state = 60}, - [1733] = {.lex_state = 36}, - [1734] = {.lex_state = 642}, - [1735] = {.lex_state = 36}, - [1736] = {.lex_state = 36}, - [1737] = {.lex_state = 642}, - [1738] = {.lex_state = 642}, - [1739] = {.lex_state = 642}, - [1740] = {.lex_state = 642}, - [1741] = {.lex_state = 642}, - [1742] = {.lex_state = 36}, - [1743] = {.lex_state = 36}, - [1744] = {.lex_state = 36}, - [1745] = {.lex_state = 642}, - [1746] = {.lex_state = 642}, - [1747] = {.lex_state = 36}, - [1748] = {.lex_state = 642}, - [1749] = {.lex_state = 36}, - [1750] = {.lex_state = 36}, - [1751] = {.lex_state = 36}, - [1752] = {.lex_state = 642}, - [1753] = {.lex_state = 36}, - [1754] = {.lex_state = 36, .external_lex_state = 1}, - [1755] = {.lex_state = 642}, - [1756] = {.lex_state = 642}, - [1757] = {.lex_state = 642}, - [1758] = {.lex_state = 642}, - [1759] = {.lex_state = 36}, - [1760] = {.lex_state = 36}, - [1761] = {.lex_state = 642}, - [1762] = {.lex_state = 642}, - [1763] = {.lex_state = 642}, - [1764] = {.lex_state = 642}, - [1765] = {.lex_state = 642}, - [1766] = {.lex_state = 36}, - [1767] = {.lex_state = 36}, - [1768] = {.lex_state = 36}, - [1769] = {.lex_state = 642}, - [1770] = {.lex_state = 642}, - [1771] = {.lex_state = 642}, - [1772] = {.lex_state = 60}, - [1773] = {.lex_state = 36}, - [1774] = {.lex_state = 642}, - [1775] = {.lex_state = 36, .external_lex_state = 1}, - [1776] = {.lex_state = 48}, - [1777] = {.lex_state = 36, .external_lex_state = 1}, - [1778] = {.lex_state = 97}, - [1779] = {.lex_state = 50}, - [1780] = {.lex_state = 48}, - [1781] = {.lex_state = 88}, - [1782] = {.lex_state = 36, .external_lex_state = 1}, - [1783] = {.lex_state = 642}, - [1784] = {.lex_state = 642}, - [1785] = {.lex_state = 642}, - [1786] = {.lex_state = 48}, - [1787] = {.lex_state = 59}, - [1788] = {.lex_state = 48}, - [1789] = {.lex_state = 36, .external_lex_state = 1}, - [1790] = {.lex_state = 59}, - [1791] = {.lex_state = 36, .external_lex_state = 1}, - [1792] = {.lex_state = 59}, - [1793] = {.lex_state = 50}, - [1794] = {.lex_state = 36, .external_lex_state = 1}, - [1795] = {.lex_state = 60}, - [1796] = {.lex_state = 48}, - [1797] = {.lex_state = 97}, - [1798] = {.lex_state = 642}, - [1799] = {.lex_state = 59}, - [1800] = {.lex_state = 59}, - [1801] = {.lex_state = 48}, - [1802] = {.lex_state = 50}, - [1803] = {.lex_state = 36}, - [1804] = {.lex_state = 50}, - [1805] = {.lex_state = 642}, - [1806] = {.lex_state = 642}, - [1807] = {.lex_state = 36}, - [1808] = {.lex_state = 642}, - [1809] = {.lex_state = 50}, - [1810] = {.lex_state = 60}, - [1811] = {.lex_state = 36}, - [1812] = {.lex_state = 50}, - [1813] = {.lex_state = 642}, - [1814] = {.lex_state = 642}, - [1815] = {.lex_state = 60}, - [1816] = {.lex_state = 60}, - [1817] = {.lex_state = 50}, - [1818] = {.lex_state = 36}, - [1819] = {.lex_state = 642}, - [1820] = {.lex_state = 642}, - [1821] = {.lex_state = 60}, - [1822] = {.lex_state = 642}, - [1823] = {.lex_state = 642}, - [1824] = {.lex_state = 642}, - [1825] = {.lex_state = 642}, - [1826] = {.lex_state = 642}, - [1827] = {.lex_state = 642}, - [1828] = {.lex_state = 36}, - [1829] = {.lex_state = 642}, - [1830] = {.lex_state = 50}, - [1831] = {.lex_state = 642}, - [1832] = {.lex_state = 642}, - [1833] = {.lex_state = 48}, - [1834] = {.lex_state = 60}, - [1835] = {.lex_state = 642}, - [1836] = {.lex_state = 60}, - [1837] = {.lex_state = 642}, - [1838] = {.lex_state = 642}, - [1839] = {.lex_state = 642}, - [1840] = {.lex_state = 642}, - [1841] = {.lex_state = 642}, - [1842] = {.lex_state = 642}, - [1843] = {.lex_state = 642}, - [1844] = {.lex_state = 36}, - [1845] = {.lex_state = 642}, - [1846] = {.lex_state = 642}, - [1847] = {.lex_state = 642}, - [1848] = {.lex_state = 642}, - [1849] = {.lex_state = 642}, - [1850] = {.lex_state = 36}, - [1851] = {.lex_state = 642}, - [1852] = {.lex_state = 642}, - [1853] = {.lex_state = 36}, - [1854] = {.lex_state = 88}, - [1855] = {.lex_state = 642}, - [1856] = {.lex_state = 61}, - [1857] = {.lex_state = 642}, - [1858] = {.lex_state = 642}, - [1859] = {.lex_state = 36}, - [1860] = {.lex_state = 642}, - [1861] = {.lex_state = 642}, - [1862] = {.lex_state = 642}, - [1863] = {.lex_state = 642}, - [1864] = {.lex_state = 642}, - [1865] = {.lex_state = 95}, - [1866] = {.lex_state = 642}, - [1867] = {.lex_state = 642}, - [1868] = {.lex_state = 642}, - [1869] = {.lex_state = 642}, - [1870] = {.lex_state = 642}, - [1871] = {.lex_state = 36}, - [1872] = {.lex_state = 36}, - [1873] = {.lex_state = 642}, - [1874] = {.lex_state = 642}, - [1875] = {.lex_state = 36}, - [1876] = {.lex_state = 36}, - [1877] = {.lex_state = 642}, - [1878] = {.lex_state = 642}, - [1879] = {.lex_state = 642}, - [1880] = {.lex_state = 642}, - [1881] = {.lex_state = 642}, - [1882] = {.lex_state = 642}, - [1883] = {.lex_state = 642}, - [1884] = {.lex_state = 642}, - [1885] = {.lex_state = 642}, - [1886] = {.lex_state = 642}, - [1887] = {.lex_state = 95}, - [1888] = {.lex_state = 36}, - [1889] = {.lex_state = 642}, - [1890] = {.lex_state = 642}, - [1891] = {.lex_state = 642}, - [1892] = {.lex_state = 642}, - [1893] = {.lex_state = 642}, - [1894] = {.lex_state = 58}, - [1895] = {.lex_state = 642}, - [1896] = {.lex_state = 36}, - [1897] = {.lex_state = 61}, - [1898] = {.lex_state = 642}, - [1899] = {.lex_state = 642}, - [1900] = {.lex_state = 642}, - [1901] = {.lex_state = 642}, - [1902] = {.lex_state = 642}, - [1903] = {.lex_state = 642}, - [1904] = {.lex_state = 642}, - [1905] = {.lex_state = 642}, - [1906] = {.lex_state = 642}, - [1907] = {.lex_state = 642}, - [1908] = {.lex_state = 642}, - [1909] = {.lex_state = 36}, - [1910] = {.lex_state = 36}, - [1911] = {.lex_state = 36}, - [1912] = {.lex_state = 642}, - [1913] = {.lex_state = 642}, - [1914] = {.lex_state = 642}, - [1915] = {.lex_state = 642}, - [1916] = {.lex_state = 642}, - [1917] = {.lex_state = 642}, - [1918] = {.lex_state = 642}, - [1919] = {.lex_state = 642}, - [1920] = {.lex_state = 642}, - [1921] = {.lex_state = 642}, - [1922] = {.lex_state = 58}, - [1923] = {.lex_state = 88}, - [1924] = {.lex_state = 642}, - [1925] = {.lex_state = 58}, - [1926] = {.lex_state = 642}, - [1927] = {.lex_state = 642}, - [1928] = {.lex_state = 642}, - [1929] = {.lex_state = 36}, - [1930] = {.lex_state = 95}, - [1931] = {.lex_state = 642}, - [1932] = {.lex_state = 36}, - [1933] = {.lex_state = 642}, - [1934] = {.lex_state = 642}, - [1935] = {.lex_state = 642}, - [1936] = {.lex_state = 642}, - [1937] = {.lex_state = 36}, - [1938] = {.lex_state = 642}, - [1939] = {.lex_state = 642}, - [1940] = {.lex_state = 642}, - [1941] = {.lex_state = 642}, - [1942] = {.lex_state = 642}, - [1943] = {.lex_state = 642}, - [1944] = {.lex_state = 36}, - [1945] = {.lex_state = 642}, - [1946] = {.lex_state = 642}, - [1947] = {.lex_state = 642}, - [1948] = {.lex_state = 642}, - [1949] = {.lex_state = 642}, - [1950] = {.lex_state = 642}, - [1951] = {.lex_state = 642}, - [1952] = {.lex_state = 642}, - [1953] = {.lex_state = 642}, - [1954] = {.lex_state = 642}, - [1955] = {.lex_state = 642}, - [1956] = {.lex_state = 642}, - [1957] = {.lex_state = 642}, - [1958] = {.lex_state = 642}, - [1959] = {.lex_state = 642}, - [1960] = {.lex_state = 642}, - [1961] = {.lex_state = 60}, - [1962] = {.lex_state = 642}, - [1963] = {.lex_state = 642}, - [1964] = {.lex_state = 642}, - [1965] = {.lex_state = 642}, - [1966] = {.lex_state = 642}, - [1967] = {.lex_state = 642}, - [1968] = {.lex_state = 642}, - [1969] = {.lex_state = 642}, - [1970] = {.lex_state = 50}, - [1971] = {.lex_state = 642}, - [1972] = {.lex_state = 642}, - [1973] = {.lex_state = 642}, - [1974] = {.lex_state = 87}, - [1975] = {.lex_state = 642}, - [1976] = {.lex_state = 642}, - [1977] = {.lex_state = 642}, - [1978] = {.lex_state = 642}, - [1979] = {.lex_state = 642}, - [1980] = {.lex_state = 642}, - [1981] = {.lex_state = 642}, - [1982] = {.lex_state = 642}, - [1983] = {.lex_state = 642}, - [1984] = {.lex_state = 642}, - [1985] = {.lex_state = 642}, - [1986] = {.lex_state = 642}, - [1987] = {.lex_state = 642}, - [1988] = {.lex_state = 642}, - [1989] = {.lex_state = 642}, - [1990] = {.lex_state = 642}, - [1991] = {.lex_state = 642}, - [1992] = {.lex_state = 60}, - [1993] = {.lex_state = 94}, - [1994] = {.lex_state = 642}, - [1995] = {.lex_state = 642}, - [1996] = {.lex_state = 642}, - [1997] = {.lex_state = 642}, - [1998] = {.lex_state = 642}, - [1999] = {.lex_state = 642}, - [2000] = {.lex_state = 642}, - [2001] = {.lex_state = 642}, - [2002] = {.lex_state = 642}, - [2003] = {.lex_state = 61}, - [2004] = {.lex_state = 642}, - [2005] = {.lex_state = 642}, - [2006] = {.lex_state = 642}, - [2007] = {.lex_state = 642}, - [2008] = {.lex_state = 642}, - [2009] = {.lex_state = 642}, - [2010] = {.lex_state = 642}, - [2011] = {.lex_state = 642}, - [2012] = {.lex_state = 642}, - [2013] = {.lex_state = 642}, - [2014] = {.lex_state = 642}, - [2015] = {.lex_state = 87}, - [2016] = {.lex_state = 642}, - [2017] = {.lex_state = 642}, - [2018] = {.lex_state = 642}, - [2019] = {.lex_state = 642}, - [2020] = {.lex_state = 642}, - [2021] = {.lex_state = 642}, - [2022] = {.lex_state = 642}, - [2023] = {.lex_state = 642}, - [2024] = {.lex_state = 642}, - [2025] = {.lex_state = 642}, - [2026] = {.lex_state = 642}, - [2027] = {.lex_state = 642}, - [2028] = {.lex_state = 642}, - [2029] = {.lex_state = 50}, - [2030] = {.lex_state = 642}, - [2031] = {.lex_state = 642}, - [2032] = {.lex_state = 87}, - [2033] = {.lex_state = 642}, - [2034] = {.lex_state = 87}, - [2035] = {.lex_state = 642}, - [2036] = {.lex_state = 642}, - [2037] = {.lex_state = 642}, - [2038] = {.lex_state = 642}, - [2039] = {.lex_state = 87}, - [2040] = {.lex_state = 60}, - [2041] = {.lex_state = 642}, - [2042] = {.lex_state = 642}, - [2043] = {.lex_state = 642}, - [2044] = {.lex_state = 642}, - [2045] = {.lex_state = 642}, - [2046] = {.lex_state = 642}, - [2047] = {.lex_state = 60}, - [2048] = {.lex_state = 642}, - [2049] = {.lex_state = 94}, - [2050] = {.lex_state = 642}, - [2051] = {.lex_state = 642}, - [2052] = {.lex_state = 642}, - [2053] = {.lex_state = 642}, - [2054] = {.lex_state = 642}, - [2055] = {.lex_state = 642}, - [2056] = {.lex_state = 60}, - [2057] = {.lex_state = 642}, - [2058] = {.lex_state = 642}, - [2059] = {.lex_state = 60}, - [2060] = {.lex_state = 642}, - [2061] = {.lex_state = 642}, - [2062] = {.lex_state = 642}, - [2063] = {.lex_state = 642}, - [2064] = {.lex_state = 642}, - [2065] = {.lex_state = 642}, - [2066] = {.lex_state = 642}, - [2067] = {.lex_state = 642}, - [2068] = {.lex_state = 642}, - [2069] = {.lex_state = 60}, - [2070] = {.lex_state = 642}, - [2071] = {.lex_state = 642}, - [2072] = {.lex_state = 642}, - [2073] = {.lex_state = 642}, - [2074] = {.lex_state = 60}, - [2075] = {.lex_state = 642}, - [2076] = {.lex_state = 642}, - [2077] = {.lex_state = 642}, - [2078] = {.lex_state = 642}, - [2079] = {.lex_state = 55}, - [2080] = {.lex_state = 60}, - [2081] = {.lex_state = 57}, - [2082] = {.lex_state = 642}, - [2083] = {.lex_state = 642}, - [2084] = {.lex_state = 642}, - [2085] = {.lex_state = 642}, - [2086] = {.lex_state = 642}, - [2087] = {.lex_state = 55}, - [2088] = {.lex_state = 642}, - [2089] = {.lex_state = 642}, - [2090] = {.lex_state = 642}, - [2091] = {.lex_state = 55}, - [2092] = {.lex_state = 642}, - [2093] = {.lex_state = 98}, - [2094] = {.lex_state = 642}, - [2095] = {.lex_state = 642}, - [2096] = {.lex_state = 642}, - [2097] = {.lex_state = 67}, - [2098] = {.lex_state = 642}, - [2099] = {.lex_state = 642}, - [2100] = {.lex_state = 101}, - [2101] = {.lex_state = 642}, - [2102] = {.lex_state = 642}, - [2103] = {.lex_state = 55}, - [2104] = {.lex_state = 67}, - [2105] = {.lex_state = 642}, - [2106] = {.lex_state = 57}, - [2107] = {.lex_state = 95}, - [2108] = {.lex_state = 55}, - [2109] = {.lex_state = 57}, - [2110] = {.lex_state = 55}, - [2111] = {.lex_state = 642}, - [2112] = {.lex_state = 642}, - [2113] = {.lex_state = 57}, - [2114] = {.lex_state = 55}, - [2115] = {.lex_state = 642}, - [2116] = {.lex_state = 95}, - [2117] = {.lex_state = 60}, - [2118] = {.lex_state = 642}, - [2119] = {.lex_state = 642}, - [2120] = {.lex_state = 50}, - [2121] = {.lex_state = 67}, - [2122] = {.lex_state = 642}, - [2123] = {.lex_state = 642}, - [2124] = {.lex_state = 642}, - [2125] = {.lex_state = 642}, - [2126] = {.lex_state = 57}, - [2127] = {.lex_state = 55}, - [2128] = {.lex_state = 60}, - [2129] = {.lex_state = 67}, - [2130] = {.lex_state = 60}, - [2131] = {.lex_state = 57}, - [2132] = {.lex_state = 55}, - [2133] = {.lex_state = 60}, - [2134] = {.lex_state = 642}, - [2135] = {.lex_state = 642}, - [2136] = {.lex_state = 95}, - [2137] = {.lex_state = 98}, - [2138] = {.lex_state = 642}, - [2139] = {.lex_state = 98}, - [2140] = {.lex_state = 50}, - [2141] = {.lex_state = 59}, - [2142] = {.lex_state = 642}, - [2143] = {.lex_state = 642}, - [2144] = {.lex_state = 55}, - [2145] = {.lex_state = 57}, - [2146] = {.lex_state = 59}, - [2147] = {.lex_state = 59}, - [2148] = {.lex_state = 642}, + [1713] = {.lex_state = 58}, + [1714] = {.lex_state = 58}, + [1715] = {.lex_state = 58}, + [1716] = {.lex_state = 97}, + [1717] = {.lex_state = 58}, + [1718] = {.lex_state = 58}, + [1719] = {.lex_state = 58}, + [1720] = {.lex_state = 734}, + [1721] = {.lex_state = 58}, + [1722] = {.lex_state = 734, .external_lex_state = 1}, + [1723] = {.lex_state = 58}, + [1724] = {.lex_state = 58}, + [1725] = {.lex_state = 58}, + [1726] = {.lex_state = 58}, + [1727] = {.lex_state = 97}, + [1728] = {.lex_state = 58}, + [1729] = {.lex_state = 97}, + [1730] = {.lex_state = 58}, + [1731] = {.lex_state = 97}, + [1732] = {.lex_state = 97}, + [1733] = {.lex_state = 97}, + [1734] = {.lex_state = 58}, + [1735] = {.lex_state = 58}, + [1736] = {.lex_state = 58}, + [1737] = {.lex_state = 58}, + [1738] = {.lex_state = 58}, + [1739] = {.lex_state = 58}, + [1740] = {.lex_state = 97}, + [1741] = {.lex_state = 58}, + [1742] = {.lex_state = 58}, + [1743] = {.lex_state = 58}, + [1744] = {.lex_state = 58}, + [1745] = {.lex_state = 58}, + [1746] = {.lex_state = 58}, + [1747] = {.lex_state = 58}, + [1748] = {.lex_state = 58}, + [1749] = {.lex_state = 58}, + [1750] = {.lex_state = 58}, + [1751] = {.lex_state = 58}, + [1752] = {.lex_state = 58}, + [1753] = {.lex_state = 58}, + [1754] = {.lex_state = 58}, + [1755] = {.lex_state = 58}, + [1756] = {.lex_state = 58}, + [1757] = {.lex_state = 58}, + [1758] = {.lex_state = 58, .external_lex_state = 1}, + [1759] = {.lex_state = 58}, + [1760] = {.lex_state = 58}, + [1761] = {.lex_state = 58}, + [1762] = {.lex_state = 97}, + [1763] = {.lex_state = 58}, + [1764] = {.lex_state = 58, .external_lex_state = 1}, + [1765] = {.lex_state = 97}, + [1766] = {.lex_state = 58}, + [1767] = {.lex_state = 97}, + [1768] = {.lex_state = 58}, + [1769] = {.lex_state = 58}, + [1770] = {.lex_state = 58}, + [1771] = {.lex_state = 734}, + [1772] = {.lex_state = 734}, + [1773] = {.lex_state = 734}, + [1774] = {.lex_state = 58, .external_lex_state = 1}, + [1775] = {.lex_state = 734}, + [1776] = {.lex_state = 94}, + [1777] = {.lex_state = 94}, + [1778] = {.lex_state = 60, .external_lex_state = 1}, + [1779] = {.lex_state = 58}, + [1780] = {.lex_state = 734}, + [1781] = {.lex_state = 734}, + [1782] = {.lex_state = 734}, + [1783] = {.lex_state = 734}, + [1784] = {.lex_state = 734}, + [1785] = {.lex_state = 734}, + [1786] = {.lex_state = 734}, + [1787] = {.lex_state = 734}, + [1788] = {.lex_state = 58}, + [1789] = {.lex_state = 734}, + [1790] = {.lex_state = 59, .external_lex_state = 1}, + [1791] = {.lex_state = 734}, + [1792] = {.lex_state = 58}, + [1793] = {.lex_state = 734}, + [1794] = {.lex_state = 734}, + [1795] = {.lex_state = 734}, + [1796] = {.lex_state = 59, .external_lex_state = 1}, + [1797] = {.lex_state = 58}, + [1798] = {.lex_state = 734}, + [1799] = {.lex_state = 734}, + [1800] = {.lex_state = 58}, + [1801] = {.lex_state = 734}, + [1802] = {.lex_state = 734, .external_lex_state = 1}, + [1803] = {.lex_state = 734}, + [1804] = {.lex_state = 734}, + [1805] = {.lex_state = 734}, + [1806] = {.lex_state = 734}, + [1807] = {.lex_state = 734, .external_lex_state = 1}, + [1808] = {.lex_state = 734}, + [1809] = {.lex_state = 734}, + [1810] = {.lex_state = 734}, + [1811] = {.lex_state = 58}, + [1812] = {.lex_state = 734}, + [1813] = {.lex_state = 734}, + [1814] = {.lex_state = 734}, + [1815] = {.lex_state = 734}, + [1816] = {.lex_state = 58, .external_lex_state = 1}, + [1817] = {.lex_state = 734}, + [1818] = {.lex_state = 734}, + [1819] = {.lex_state = 734}, + [1820] = {.lex_state = 734}, + [1821] = {.lex_state = 734}, + [1822] = {.lex_state = 734}, + [1823] = {.lex_state = 58}, + [1824] = {.lex_state = 58}, + [1825] = {.lex_state = 734}, + [1826] = {.lex_state = 734}, + [1827] = {.lex_state = 734}, + [1828] = {.lex_state = 734}, + [1829] = {.lex_state = 58}, + [1830] = {.lex_state = 734}, + [1831] = {.lex_state = 58}, + [1832] = {.lex_state = 734}, + [1833] = {.lex_state = 734}, + [1834] = {.lex_state = 58}, + [1835] = {.lex_state = 734}, + [1836] = {.lex_state = 58}, + [1837] = {.lex_state = 734}, + [1838] = {.lex_state = 734}, + [1839] = {.lex_state = 734}, + [1840] = {.lex_state = 734}, + [1841] = {.lex_state = 58}, + [1842] = {.lex_state = 734}, + [1843] = {.lex_state = 734}, + [1844] = {.lex_state = 734}, + [1845] = {.lex_state = 58}, + [1846] = {.lex_state = 59, .external_lex_state = 1}, + [1847] = {.lex_state = 59}, + [1848] = {.lex_state = 58}, + [1849] = {.lex_state = 734}, + [1850] = {.lex_state = 58}, + [1851] = {.lex_state = 734}, + [1852] = {.lex_state = 734}, + [1853] = {.lex_state = 58}, + [1854] = {.lex_state = 734}, + [1855] = {.lex_state = 58}, + [1856] = {.lex_state = 734}, + [1857] = {.lex_state = 734}, + [1858] = {.lex_state = 734}, + [1859] = {.lex_state = 734}, + [1860] = {.lex_state = 58}, + [1861] = {.lex_state = 734}, + [1862] = {.lex_state = 734}, + [1863] = {.lex_state = 734}, + [1864] = {.lex_state = 734}, + [1865] = {.lex_state = 734}, + [1866] = {.lex_state = 734}, + [1867] = {.lex_state = 734}, + [1868] = {.lex_state = 734}, + [1869] = {.lex_state = 734}, + [1870] = {.lex_state = 734}, + [1871] = {.lex_state = 734}, + [1872] = {.lex_state = 58}, + [1873] = {.lex_state = 734}, + [1874] = {.lex_state = 734}, + [1875] = {.lex_state = 734}, + [1876] = {.lex_state = 734}, + [1877] = {.lex_state = 734}, + [1878] = {.lex_state = 58}, + [1879] = {.lex_state = 734}, + [1880] = {.lex_state = 734}, + [1881] = {.lex_state = 734}, + [1882] = {.lex_state = 734}, + [1883] = {.lex_state = 734}, + [1884] = {.lex_state = 734}, + [1885] = {.lex_state = 734}, + [1886] = {.lex_state = 734}, + [1887] = {.lex_state = 734}, + [1888] = {.lex_state = 734}, + [1889] = {.lex_state = 734}, + [1890] = {.lex_state = 734}, + [1891] = {.lex_state = 734}, + [1892] = {.lex_state = 59}, + [1893] = {.lex_state = 59}, + [1894] = {.lex_state = 734}, + [1895] = {.lex_state = 734}, + [1896] = {.lex_state = 50}, + [1897] = {.lex_state = 59}, + [1898] = {.lex_state = 50}, + [1899] = {.lex_state = 68}, + [1900] = {.lex_state = 68}, + [1901] = {.lex_state = 734}, + [1902] = {.lex_state = 58}, + [1903] = {.lex_state = 734}, + [1904] = {.lex_state = 734}, + [1905] = {.lex_state = 734}, + [1906] = {.lex_state = 734}, + [1907] = {.lex_state = 734}, + [1908] = {.lex_state = 59}, + [1909] = {.lex_state = 734}, + [1910] = {.lex_state = 734}, + [1911] = {.lex_state = 50}, + [1912] = {.lex_state = 734}, + [1913] = {.lex_state = 734}, + [1914] = {.lex_state = 50}, + [1915] = {.lex_state = 734}, + [1916] = {.lex_state = 68}, + [1917] = {.lex_state = 734}, + [1918] = {.lex_state = 734}, + [1919] = {.lex_state = 734}, + [1920] = {.lex_state = 734, .external_lex_state = 1}, + [1921] = {.lex_state = 59}, + [1922] = {.lex_state = 50}, + [1923] = {.lex_state = 734}, + [1924] = {.lex_state = 734}, + [1925] = {.lex_state = 734}, + [1926] = {.lex_state = 734}, + [1927] = {.lex_state = 50}, + [1928] = {.lex_state = 60, .external_lex_state = 1}, + [1929] = {.lex_state = 734}, + [1930] = {.lex_state = 734}, + [1931] = {.lex_state = 734}, + [1932] = {.lex_state = 58}, + [1933] = {.lex_state = 50}, + [1934] = {.lex_state = 60, .external_lex_state = 1}, + [1935] = {.lex_state = 68}, + [1936] = {.lex_state = 68}, + [1937] = {.lex_state = 68}, + [1938] = {.lex_state = 734}, + [1939] = {.lex_state = 734}, + [1940] = {.lex_state = 734}, + [1941] = {.lex_state = 734}, + [1942] = {.lex_state = 734}, + [1943] = {.lex_state = 50}, + [1944] = {.lex_state = 734}, + [1945] = {.lex_state = 734}, + [1946] = {.lex_state = 734}, + [1947] = {.lex_state = 734}, + [1948] = {.lex_state = 734}, + [1949] = {.lex_state = 734}, + [1950] = {.lex_state = 734}, + [1951] = {.lex_state = 734}, + [1952] = {.lex_state = 734}, + [1953] = {.lex_state = 58}, + [1954] = {.lex_state = 734, .external_lex_state = 1}, + [1955] = {.lex_state = 58}, + [1956] = {.lex_state = 734}, + [1957] = {.lex_state = 734}, + [1958] = {.lex_state = 734}, + [1959] = {.lex_state = 734}, + [1960] = {.lex_state = 58}, + [1961] = {.lex_state = 734}, + [1962] = {.lex_state = 734}, + [1963] = {.lex_state = 734}, + [1964] = {.lex_state = 734}, + [1965] = {.lex_state = 734}, + [1966] = {.lex_state = 734}, + [1967] = {.lex_state = 734}, + [1968] = {.lex_state = 734}, + [1969] = {.lex_state = 734}, + [1970] = {.lex_state = 734}, + [1971] = {.lex_state = 734}, + [1972] = {.lex_state = 734}, + [1973] = {.lex_state = 734}, + [1974] = {.lex_state = 734}, + [1975] = {.lex_state = 734}, + [1976] = {.lex_state = 734}, + [1977] = {.lex_state = 734}, + [1978] = {.lex_state = 734}, + [1979] = {.lex_state = 734}, + [1980] = {.lex_state = 734}, + [1981] = {.lex_state = 734}, + [1982] = {.lex_state = 734}, + [1983] = {.lex_state = 734}, + [1984] = {.lex_state = 734}, + [1985] = {.lex_state = 60, .external_lex_state = 1}, + [1986] = {.lex_state = 734}, + [1987] = {.lex_state = 734}, + [1988] = {.lex_state = 734}, + [1989] = {.lex_state = 734}, + [1990] = {.lex_state = 734}, + [1991] = {.lex_state = 734}, + [1992] = {.lex_state = 734}, + [1993] = {.lex_state = 60}, + [1994] = {.lex_state = 734}, + [1995] = {.lex_state = 734}, + [1996] = {.lex_state = 734}, + [1997] = {.lex_state = 734}, + [1998] = {.lex_state = 734}, + [1999] = {.lex_state = 58}, + [2000] = {.lex_state = 734}, + [2001] = {.lex_state = 734}, + [2002] = {.lex_state = 734}, + [2003] = {.lex_state = 58}, + [2004] = {.lex_state = 734}, + [2005] = {.lex_state = 734}, + [2006] = {.lex_state = 734}, + [2007] = {.lex_state = 734}, + [2008] = {.lex_state = 734}, + [2009] = {.lex_state = 734}, + [2010] = {.lex_state = 734}, + [2011] = {.lex_state = 58}, + [2012] = {.lex_state = 734}, + [2013] = {.lex_state = 734, .external_lex_state = 1}, + [2014] = {.lex_state = 734, .external_lex_state = 1}, + [2015] = {.lex_state = 50}, + [2016] = {.lex_state = 734, .external_lex_state = 1}, + [2017] = {.lex_state = 93}, + [2018] = {.lex_state = 60}, + [2019] = {.lex_state = 734, .external_lex_state = 1}, + [2020] = {.lex_state = 104}, + [2021] = {.lex_state = 734, .external_lex_state = 1}, + [2022] = {.lex_state = 734, .external_lex_state = 1}, + [2023] = {.lex_state = 734, .external_lex_state = 1}, + [2024] = {.lex_state = 734, .external_lex_state = 1}, + [2025] = {.lex_state = 104}, + [2026] = {.lex_state = 50}, + [2027] = {.lex_state = 734, .external_lex_state = 1}, + [2028] = {.lex_state = 50}, + [2029] = {.lex_state = 93}, + [2030] = {.lex_state = 60}, + [2031] = {.lex_state = 93}, + [2032] = {.lex_state = 94}, + [2033] = {.lex_state = 60}, + [2034] = {.lex_state = 60}, + [2035] = {.lex_state = 60}, + [2036] = {.lex_state = 734}, + [2037] = {.lex_state = 93}, + [2038] = {.lex_state = 68}, + [2039] = {.lex_state = 734}, + [2040] = {.lex_state = 61}, + [2041] = {.lex_state = 68}, + [2042] = {.lex_state = 68}, + [2043] = {.lex_state = 61}, + [2044] = {.lex_state = 61}, + [2045] = {.lex_state = 734}, + [2046] = {.lex_state = 734}, + [2047] = {.lex_state = 734}, + [2048] = {.lex_state = 734}, + [2049] = {.lex_state = 61}, + [2050] = {.lex_state = 734}, + [2051] = {.lex_state = 734}, + [2052] = {.lex_state = 50}, + [2053] = {.lex_state = 61}, + [2054] = {.lex_state = 61}, + [2055] = {.lex_state = 68}, + [2056] = {.lex_state = 68}, + [2057] = {.lex_state = 50}, + [2058] = {.lex_state = 734}, + [2059] = {.lex_state = 68}, + [2060] = {.lex_state = 50}, + [2061] = {.lex_state = 68}, + [2062] = {.lex_state = 734}, + [2063] = {.lex_state = 50}, + [2064] = {.lex_state = 734}, + [2065] = {.lex_state = 50}, + [2066] = {.lex_state = 734}, + [2067] = {.lex_state = 734}, + [2068] = {.lex_state = 68}, + [2069] = {.lex_state = 68}, + [2070] = {.lex_state = 61}, + [2071] = {.lex_state = 734}, + [2072] = {.lex_state = 68}, + [2073] = {.lex_state = 68}, + [2074] = {.lex_state = 734}, + [2075] = {.lex_state = 68}, + [2076] = {.lex_state = 734}, + [2077] = {.lex_state = 734}, + [2078] = {.lex_state = 734}, + [2079] = {.lex_state = 734}, + [2080] = {.lex_state = 734}, + [2081] = {.lex_state = 68}, + [2082] = {.lex_state = 68}, + [2083] = {.lex_state = 68}, + [2084] = {.lex_state = 734}, + [2085] = {.lex_state = 734}, + [2086] = {.lex_state = 50}, + [2087] = {.lex_state = 68}, + [2088] = {.lex_state = 61}, + [2089] = {.lex_state = 734}, + [2090] = {.lex_state = 68}, + [2091] = {.lex_state = 734}, + [2092] = {.lex_state = 68}, + [2093] = {.lex_state = 734}, + [2094] = {.lex_state = 734}, + [2095] = {.lex_state = 734}, + [2096] = {.lex_state = 50}, + [2097] = {.lex_state = 734}, + [2098] = {.lex_state = 734}, + [2099] = {.lex_state = 734, .external_lex_state = 1}, + [2100] = {.lex_state = 734}, + [2101] = {.lex_state = 734}, + [2102] = {.lex_state = 734}, + [2103] = {.lex_state = 734}, + [2104] = {.lex_state = 734}, + [2105] = {.lex_state = 734}, + [2106] = {.lex_state = 734}, + [2107] = {.lex_state = 734}, + [2108] = {.lex_state = 734}, + [2109] = {.lex_state = 734}, + [2110] = {.lex_state = 734}, + [2111] = {.lex_state = 734}, + [2112] = {.lex_state = 734}, + [2113] = {.lex_state = 734}, + [2114] = {.lex_state = 734}, + [2115] = {.lex_state = 734}, + [2116] = {.lex_state = 734}, + [2117] = {.lex_state = 734}, + [2118] = {.lex_state = 734}, + [2119] = {.lex_state = 734}, + [2120] = {.lex_state = 734}, + [2121] = {.lex_state = 734}, + [2122] = {.lex_state = 734}, + [2123] = {.lex_state = 734}, + [2124] = {.lex_state = 734}, + [2125] = {.lex_state = 734}, + [2126] = {.lex_state = 734}, + [2127] = {.lex_state = 734}, + [2128] = {.lex_state = 734}, + [2129] = {.lex_state = 734}, + [2130] = {.lex_state = 734}, + [2131] = {.lex_state = 734}, + [2132] = {.lex_state = 734}, + [2133] = {.lex_state = 734}, + [2134] = {.lex_state = 734}, + [2135] = {.lex_state = 734}, + [2136] = {.lex_state = 734}, + [2137] = {.lex_state = 734, .external_lex_state = 1}, + [2138] = {.lex_state = 734}, + [2139] = {.lex_state = 734}, + [2140] = {.lex_state = 734}, + [2141] = {.lex_state = 734}, + [2142] = {.lex_state = 734}, + [2143] = {.lex_state = 734}, + [2144] = {.lex_state = 734}, + [2145] = {.lex_state = 734}, + [2146] = {.lex_state = 734}, + [2147] = {.lex_state = 734}, + [2148] = {.lex_state = 734}, [2149] = {.lex_state = 101}, - [2150] = {.lex_state = 50}, - [2151] = {.lex_state = 50}, - [2152] = {.lex_state = 642}, - [2153] = {.lex_state = 55}, - [2154] = {.lex_state = 50}, - [2155] = {.lex_state = 57}, - [2156] = {.lex_state = 642}, - [2157] = {.lex_state = 642}, - [2158] = {.lex_state = 50}, - [2159] = {.lex_state = 642}, - [2160] = {.lex_state = 98}, - [2161] = {.lex_state = 50}, - [2162] = {.lex_state = 642}, - [2163] = {.lex_state = 60}, - [2164] = {.lex_state = 60}, - [2165] = {.lex_state = 642}, - [2166] = {.lex_state = 55}, - [2167] = {.lex_state = 57}, - [2168] = {.lex_state = 57}, - [2169] = {.lex_state = 642}, - [2170] = {.lex_state = 642}, - [2171] = {.lex_state = 60}, - [2172] = {.lex_state = 67}, - [2173] = {.lex_state = 50}, - [2174] = {.lex_state = 98}, - [2175] = {.lex_state = 642}, - [2176] = {.lex_state = 55}, - [2177] = {.lex_state = 57}, - [2178] = {.lex_state = 642}, - [2179] = {.lex_state = 642}, - [2180] = {.lex_state = 642}, - [2181] = {.lex_state = 642}, - [2182] = {.lex_state = 642}, - [2183] = {.lex_state = 642}, - [2184] = {.lex_state = 642}, - [2185] = {.lex_state = 56}, - [2186] = {.lex_state = 642}, - [2187] = {.lex_state = 642}, - [2188] = {.lex_state = 99}, - [2189] = {.lex_state = 642}, - [2190] = {.lex_state = 50}, - [2191] = {.lex_state = 642}, - [2192] = {.lex_state = 642}, - [2193] = {.lex_state = 642}, - [2194] = {.lex_state = 642}, - [2195] = {.lex_state = 642}, - [2196] = {.lex_state = 642}, - [2197] = {.lex_state = 642}, - [2198] = {.lex_state = 642, .external_lex_state = 1}, - [2199] = {.lex_state = 642}, - [2200] = {.lex_state = 642}, - [2201] = {.lex_state = 642}, - [2202] = {.lex_state = 642}, - [2203] = {.lex_state = 642}, - [2204] = {.lex_state = 642}, - [2205] = {.lex_state = 642}, - [2206] = {.lex_state = 642}, - [2207] = {.lex_state = 41}, - [2208] = {.lex_state = 99}, - [2209] = {.lex_state = 642}, - [2210] = {.lex_state = 642}, - [2211] = {.lex_state = 642}, - [2212] = {.lex_state = 642}, - [2213] = {.lex_state = 57}, - [2214] = {.lex_state = 642}, - [2215] = {.lex_state = 642}, - [2216] = {.lex_state = 642}, - [2217] = {.lex_state = 642}, - [2218] = {.lex_state = 56}, - [2219] = {.lex_state = 55}, - [2220] = {.lex_state = 642, .external_lex_state = 1}, - [2221] = {.lex_state = 642}, - [2222] = {.lex_state = 642}, - [2223] = {.lex_state = 642, .external_lex_state = 1}, - [2224] = {.lex_state = 642}, - [2225] = {.lex_state = 642}, - [2226] = {.lex_state = 642}, - [2227] = {.lex_state = 642}, - [2228] = {.lex_state = 642, .external_lex_state = 1}, - [2229] = {.lex_state = 642}, - [2230] = {.lex_state = 642}, - [2231] = {.lex_state = 642}, + [2150] = {.lex_state = 734}, + [2151] = {.lex_state = 734}, + [2152] = {.lex_state = 734}, + [2153] = {.lex_state = 734}, + [2154] = {.lex_state = 734}, + [2155] = {.lex_state = 734}, + [2156] = {.lex_state = 734}, + [2157] = {.lex_state = 734}, + [2158] = {.lex_state = 734}, + [2159] = {.lex_state = 734}, + [2160] = {.lex_state = 734}, + [2161] = {.lex_state = 94}, + [2162] = {.lex_state = 734}, + [2163] = {.lex_state = 734}, + [2164] = {.lex_state = 734}, + [2165] = {.lex_state = 734}, + [2166] = {.lex_state = 734}, + [2167] = {.lex_state = 734}, + [2168] = {.lex_state = 734}, + [2169] = {.lex_state = 734}, + [2170] = {.lex_state = 734}, + [2171] = {.lex_state = 734}, + [2172] = {.lex_state = 101}, + [2173] = {.lex_state = 734}, + [2174] = {.lex_state = 734}, + [2175] = {.lex_state = 734, .external_lex_state = 1}, + [2176] = {.lex_state = 734}, + [2177] = {.lex_state = 734}, + [2178] = {.lex_state = 734}, + [2179] = {.lex_state = 734}, + [2180] = {.lex_state = 734, .external_lex_state = 1}, + [2181] = {.lex_state = 68}, + [2182] = {.lex_state = 734}, + [2183] = {.lex_state = 734}, + [2184] = {.lex_state = 734}, + [2185] = {.lex_state = 734}, + [2186] = {.lex_state = 734}, + [2187] = {.lex_state = 734}, + [2188] = {.lex_state = 734}, + [2189] = {.lex_state = 734}, + [2190] = {.lex_state = 59}, + [2191] = {.lex_state = 734}, + [2192] = {.lex_state = 734}, + [2193] = {.lex_state = 734}, + [2194] = {.lex_state = 734}, + [2195] = {.lex_state = 734}, + [2196] = {.lex_state = 734}, + [2197] = {.lex_state = 59}, + [2198] = {.lex_state = 734}, + [2199] = {.lex_state = 734}, + [2200] = {.lex_state = 59}, + [2201] = {.lex_state = 734}, + [2202] = {.lex_state = 734}, + [2203] = {.lex_state = 101}, + [2204] = {.lex_state = 734}, + [2205] = {.lex_state = 734}, + [2206] = {.lex_state = 734}, + [2207] = {.lex_state = 734}, + [2208] = {.lex_state = 734}, + [2209] = {.lex_state = 734}, + [2210] = {.lex_state = 734}, + [2211] = {.lex_state = 734}, + [2212] = {.lex_state = 734}, + [2213] = {.lex_state = 734}, + [2214] = {.lex_state = 61}, + [2215] = {.lex_state = 734}, + [2216] = {.lex_state = 734}, + [2217] = {.lex_state = 734}, + [2218] = {.lex_state = 94}, + [2219] = {.lex_state = 734}, + [2220] = {.lex_state = 734}, + [2221] = {.lex_state = 734}, + [2222] = {.lex_state = 50}, + [2223] = {.lex_state = 734}, + [2224] = {.lex_state = 734}, + [2225] = {.lex_state = 734}, + [2226] = {.lex_state = 92}, + [2227] = {.lex_state = 734}, + [2228] = {.lex_state = 734}, + [2229] = {.lex_state = 734}, + [2230] = {.lex_state = 734}, + [2231] = {.lex_state = 92}, [2232] = {.lex_state = 50}, - [2233] = {.lex_state = 642}, - [2234] = {.lex_state = 642}, - [2235] = {.lex_state = 642}, - [2236] = {.lex_state = 50}, - [2237] = {.lex_state = 642}, - [2238] = {.lex_state = 642}, - [2239] = {.lex_state = 642}, - [2240] = {.lex_state = 642}, - [2241] = {.lex_state = 642}, - [2242] = {.lex_state = 642}, - [2243] = {.lex_state = 642}, - [2244] = {.lex_state = 56}, - [2245] = {.lex_state = 642}, - [2246] = {.lex_state = 642}, - [2247] = {.lex_state = 642}, - [2248] = {.lex_state = 642, .external_lex_state = 1}, - [2249] = {.lex_state = 642}, - [2250] = {.lex_state = 642}, - [2251] = {.lex_state = 642}, - [2252] = {.lex_state = 642}, - [2253] = {.lex_state = 50}, - [2254] = {.lex_state = 642}, - [2255] = {.lex_state = 642}, - [2256] = {.lex_state = 642}, - [2257] = {.lex_state = 642}, - [2258] = {.lex_state = 642}, - [2259] = {.lex_state = 642, .external_lex_state = 1}, - [2260] = {.lex_state = 642}, - [2261] = {.lex_state = 642}, - [2262] = {.lex_state = 642}, - [2263] = {.lex_state = 642}, - [2264] = {.lex_state = 642}, - [2265] = {.lex_state = 642}, - [2266] = {.lex_state = 642}, - [2267] = {.lex_state = 642}, - [2268] = {.lex_state = 642}, - [2269] = {.lex_state = 642}, - [2270] = {.lex_state = 642}, - [2271] = {.lex_state = 50}, - [2272] = {.lex_state = 642}, - [2273] = {.lex_state = 56}, - [2274] = {.lex_state = 642}, - [2275] = {.lex_state = 99}, - [2276] = {.lex_state = 642}, - [2277] = {.lex_state = 642}, - [2278] = {.lex_state = 642, .external_lex_state = 1}, - [2279] = {.lex_state = 642}, - [2280] = {.lex_state = 642}, - [2281] = {.lex_state = 642}, - [2282] = {.lex_state = 642}, - [2283] = {.lex_state = 87}, - [2284] = {.lex_state = 642}, - [2285] = {.lex_state = 642}, - [2286] = {.lex_state = 642}, - [2287] = {.lex_state = 642}, - [2288] = {.lex_state = 642}, - [2289] = {.lex_state = 642, .external_lex_state = 1}, - [2290] = {.lex_state = 642}, - [2291] = {.lex_state = 642}, - [2292] = {.lex_state = 642}, - [2293] = {.lex_state = 642}, - [2294] = {.lex_state = 642}, - [2295] = {.lex_state = 642}, - [2296] = {.lex_state = 41}, - [2297] = {.lex_state = 642}, - [2298] = {.lex_state = 642}, - [2299] = {.lex_state = 642}, - [2300] = {.lex_state = 99}, - [2301] = {.lex_state = 642}, - [2302] = {.lex_state = 50}, - [2303] = {.lex_state = 642}, - [2304] = {.lex_state = 642}, - [2305] = {.lex_state = 642}, - [2306] = {.lex_state = 642}, - [2307] = {.lex_state = 642}, - [2308] = {.lex_state = 642}, - [2309] = {.lex_state = 642}, - [2310] = {.lex_state = 642}, - [2311] = {.lex_state = 642}, - [2312] = {.lex_state = 50}, - [2313] = {.lex_state = 642}, - [2314] = {.lex_state = 642}, - [2315] = {.lex_state = 642}, - [2316] = {.lex_state = 642}, - [2317] = {.lex_state = 642}, - [2318] = {.lex_state = 50}, - [2319] = {.lex_state = 642}, - [2320] = {.lex_state = 642}, - [2321] = {.lex_state = 642}, - [2322] = {.lex_state = 642}, - [2323] = {.lex_state = 642}, - [2324] = {.lex_state = 642}, - [2325] = {.lex_state = 642}, - [2326] = {.lex_state = 642}, - [2327] = {.lex_state = 93}, - [2328] = {.lex_state = 642}, - [2329] = {.lex_state = 642}, - [2330] = {.lex_state = 642}, - [2331] = {.lex_state = 642}, - [2332] = {.lex_state = 642}, - [2333] = {.lex_state = 642}, - [2334] = {.lex_state = 642}, - [2335] = {.lex_state = 642}, - [2336] = {.lex_state = 642}, - [2337] = {.lex_state = 642}, - [2338] = {.lex_state = 642}, - [2339] = {.lex_state = 642}, - [2340] = {.lex_state = 642}, - [2341] = {.lex_state = 642}, - [2342] = {.lex_state = 642}, - [2343] = {.lex_state = 642}, - [2344] = {.lex_state = 642}, - [2345] = {.lex_state = 642}, - [2346] = {.lex_state = 642}, - [2347] = {.lex_state = 642}, - [2348] = {.lex_state = 642}, - [2349] = {.lex_state = 642}, - [2350] = {.lex_state = 642}, - [2351] = {.lex_state = 642}, - [2352] = {.lex_state = 642}, - [2353] = {.lex_state = 642}, - [2354] = {.lex_state = 642}, - [2355] = {.lex_state = 642}, - [2356] = {.lex_state = 642}, - [2357] = {.lex_state = 642}, - [2358] = {.lex_state = 642}, - [2359] = {.lex_state = 642}, - [2360] = {.lex_state = 642}, - [2361] = {.lex_state = 642}, - [2362] = {.lex_state = 642}, - [2363] = {.lex_state = 642}, - [2364] = {.lex_state = 642}, - [2365] = {.lex_state = 642}, - [2366] = {.lex_state = 642}, - [2367] = {.lex_state = 642}, - [2368] = {.lex_state = 642}, - [2369] = {.lex_state = 642}, - [2370] = {.lex_state = 642, .external_lex_state = 1}, - [2371] = {.lex_state = 642}, - [2372] = {.lex_state = 642}, - [2373] = {.lex_state = 642}, - [2374] = {.lex_state = 642}, - [2375] = {.lex_state = 642}, - [2376] = {.lex_state = 642}, - [2377] = {.lex_state = 642}, - [2378] = {.lex_state = 642}, - [2379] = {.lex_state = 642}, - [2380] = {.lex_state = 642}, - [2381] = {.lex_state = 642}, - [2382] = {.lex_state = 642}, - [2383] = {.lex_state = 642}, - [2384] = {.lex_state = 642}, - [2385] = {.lex_state = 642}, - [2386] = {.lex_state = 642}, - [2387] = {.lex_state = 642}, - [2388] = {.lex_state = 642}, - [2389] = {.lex_state = 642}, - [2390] = {.lex_state = 642}, - [2391] = {.lex_state = 642}, - [2392] = {.lex_state = 642}, - [2393] = {.lex_state = 642}, - [2394] = {.lex_state = 642}, - [2395] = {.lex_state = 642}, - [2396] = {.lex_state = 642}, - [2397] = {.lex_state = 642}, - [2398] = {.lex_state = 642}, - [2399] = {.lex_state = 642}, - [2400] = {.lex_state = 642}, - [2401] = {.lex_state = 642}, - [2402] = {.lex_state = 642}, - [2403] = {.lex_state = 642}, - [2404] = {.lex_state = 642}, - [2405] = {.lex_state = 642}, - [2406] = {.lex_state = 642}, - [2407] = {.lex_state = 93}, - [2408] = {.lex_state = 642}, - [2409] = {.lex_state = 642}, - [2410] = {.lex_state = 642}, - [2411] = {.lex_state = 642}, - [2412] = {.lex_state = 642}, - [2413] = {.lex_state = 642}, - [2414] = {.lex_state = 642}, - [2415] = {.lex_state = 41}, - [2416] = {.lex_state = 642}, - [2417] = {.lex_state = 642}, - [2418] = {.lex_state = 642}, - [2419] = {.lex_state = 642}, - [2420] = {.lex_state = 642}, - [2421] = {.lex_state = 642, .external_lex_state = 1}, - [2422] = {.lex_state = 99}, - [2423] = {.lex_state = 642}, - [2424] = {.lex_state = 50}, - [2425] = {.lex_state = 642}, - [2426] = {.lex_state = 642}, - [2427] = {.lex_state = 50}, - [2428] = {.lex_state = 642}, - [2429] = {.lex_state = 642, .external_lex_state = 1}, - [2430] = {.lex_state = 642}, - [2431] = {.lex_state = 642}, - [2432] = {.lex_state = 642}, - [2433] = {.lex_state = 642}, - [2434] = {.lex_state = 642}, - [2435] = {.lex_state = 642}, - [2436] = {.lex_state = 642}, - [2437] = {.lex_state = 642}, - [2438] = {.lex_state = 642}, - [2439] = {.lex_state = 642}, - [2440] = {.lex_state = 642}, - [2441] = {.lex_state = 642}, - [2442] = {.lex_state = 642}, - [2443] = {.lex_state = 642}, - [2444] = {.lex_state = 100}, - [2445] = {.lex_state = 642}, - [2446] = {.lex_state = 642}, - [2447] = {.lex_state = 642, .external_lex_state = 1}, - [2448] = {.lex_state = 99}, - [2449] = {.lex_state = 642}, - [2450] = {.lex_state = 642}, - [2451] = {.lex_state = 642}, - [2452] = {.lex_state = 642}, - [2453] = {.lex_state = 642}, - [2454] = {.lex_state = 642}, - [2455] = {.lex_state = 642}, - [2456] = {.lex_state = 642}, - [2457] = {.lex_state = 642}, - [2458] = {.lex_state = 642}, - [2459] = {.lex_state = 642}, - [2460] = {.lex_state = 642}, - [2461] = {.lex_state = 642}, - [2462] = {.lex_state = 642}, - [2463] = {.lex_state = 642}, - [2464] = {.lex_state = 642}, - [2465] = {.lex_state = 642}, - [2466] = {.lex_state = 642, .external_lex_state = 1}, - [2467] = {.lex_state = 642}, - [2468] = {.lex_state = 642}, - [2469] = {.lex_state = 41}, - [2470] = {.lex_state = 642}, - [2471] = {.lex_state = 642}, - [2472] = {.lex_state = 56}, - [2473] = {.lex_state = 642}, - [2474] = {.lex_state = 642}, - [2475] = {.lex_state = 642}, - [2476] = {.lex_state = 642}, - [2477] = {.lex_state = 642}, - [2478] = {.lex_state = 642}, - [2479] = {.lex_state = 642}, - [2480] = {.lex_state = 642}, - [2481] = {.lex_state = 642}, - [2482] = {.lex_state = 642}, - [2483] = {.lex_state = 642}, - [2484] = {.lex_state = 642}, - [2485] = {.lex_state = 642}, - [2486] = {.lex_state = 642}, - [2487] = {.lex_state = 642}, - [2488] = {.lex_state = 642}, - [2489] = {.lex_state = 642}, - [2490] = {.lex_state = 642, .external_lex_state = 1}, - [2491] = {.lex_state = 642}, - [2492] = {.lex_state = 642}, - [2493] = {.lex_state = 642}, - [2494] = {.lex_state = 642, .external_lex_state = 1}, - [2495] = {.lex_state = 642}, - [2496] = {.lex_state = 36}, - [2497] = {.lex_state = 642}, - [2498] = {.lex_state = 642}, - [2499] = {.lex_state = 642}, - [2500] = {.lex_state = 642}, - [2501] = {.lex_state = 642}, - [2502] = {.lex_state = 642}, - [2503] = {.lex_state = 642}, - [2504] = {.lex_state = 41}, - [2505] = {.lex_state = 100}, - [2506] = {.lex_state = 642}, - [2507] = {.lex_state = 642}, - [2508] = {.lex_state = 642}, - [2509] = {.lex_state = 642}, - [2510] = {.lex_state = 642}, - [2511] = {.lex_state = 100}, - [2512] = {.lex_state = 642}, - [2513] = {.lex_state = 642}, - [2514] = {.lex_state = 642}, - [2515] = {.lex_state = 642}, - [2516] = {.lex_state = 642}, + [2233] = {.lex_state = 734}, + [2234] = {.lex_state = 92}, + [2235] = {.lex_state = 58}, + [2236] = {.lex_state = 734, .external_lex_state = 1}, + [2237] = {.lex_state = 734}, + [2238] = {.lex_state = 734}, + [2239] = {.lex_state = 734}, + [2240] = {.lex_state = 734}, + [2241] = {.lex_state = 734}, + [2242] = {.lex_state = 734}, + [2243] = {.lex_state = 734}, + [2244] = {.lex_state = 734}, + [2245] = {.lex_state = 734}, + [2246] = {.lex_state = 92}, + [2247] = {.lex_state = 734}, + [2248] = {.lex_state = 734}, + [2249] = {.lex_state = 734}, + [2250] = {.lex_state = 734}, + [2251] = {.lex_state = 101}, + [2252] = {.lex_state = 734}, + [2253] = {.lex_state = 734}, + [2254] = {.lex_state = 734}, + [2255] = {.lex_state = 734}, + [2256] = {.lex_state = 734}, + [2257] = {.lex_state = 734}, + [2258] = {.lex_state = 68}, + [2259] = {.lex_state = 734, .external_lex_state = 1}, + [2260] = {.lex_state = 734}, + [2261] = {.lex_state = 92}, + [2262] = {.lex_state = 734}, + [2263] = {.lex_state = 734}, + [2264] = {.lex_state = 58}, + [2265] = {.lex_state = 734}, + [2266] = {.lex_state = 734, .external_lex_state = 1}, + [2267] = {.lex_state = 734}, + [2268] = {.lex_state = 734}, + [2269] = {.lex_state = 734}, + [2270] = {.lex_state = 734}, + [2271] = {.lex_state = 734}, + [2272] = {.lex_state = 734}, + [2273] = {.lex_state = 734}, + [2274] = {.lex_state = 58}, + [2275] = {.lex_state = 734}, + [2276] = {.lex_state = 734}, + [2277] = {.lex_state = 734}, + [2278] = {.lex_state = 734}, + [2279] = {.lex_state = 734}, + [2280] = {.lex_state = 734}, + [2281] = {.lex_state = 734}, + [2282] = {.lex_state = 734}, + [2283] = {.lex_state = 58}, + [2284] = {.lex_state = 734}, + [2285] = {.lex_state = 734}, + [2286] = {.lex_state = 734}, + [2287] = {.lex_state = 734}, + [2288] = {.lex_state = 734}, + [2289] = {.lex_state = 734}, + [2290] = {.lex_state = 734}, + [2291] = {.lex_state = 734}, + [2292] = {.lex_state = 734}, + [2293] = {.lex_state = 734}, + [2294] = {.lex_state = 734}, + [2295] = {.lex_state = 734}, + [2296] = {.lex_state = 734}, + [2297] = {.lex_state = 734}, + [2298] = {.lex_state = 734}, + [2299] = {.lex_state = 734}, + [2300] = {.lex_state = 734}, + [2301] = {.lex_state = 734}, + [2302] = {.lex_state = 734}, + [2303] = {.lex_state = 734}, + [2304] = {.lex_state = 734}, + [2305] = {.lex_state = 734}, + [2306] = {.lex_state = 101}, + [2307] = {.lex_state = 734}, + [2308] = {.lex_state = 734}, + [2309] = {.lex_state = 734}, + [2310] = {.lex_state = 734}, + [2311] = {.lex_state = 734}, + [2312] = {.lex_state = 734}, + [2313] = {.lex_state = 734}, + [2314] = {.lex_state = 58}, + [2315] = {.lex_state = 734}, + [2316] = {.lex_state = 58}, + [2317] = {.lex_state = 734}, + [2318] = {.lex_state = 734}, + [2319] = {.lex_state = 734}, + [2320] = {.lex_state = 734}, + [2321] = {.lex_state = 734}, + [2322] = {.lex_state = 734}, + [2323] = {.lex_state = 734}, + [2324] = {.lex_state = 734}, + [2325] = {.lex_state = 58}, + [2326] = {.lex_state = 734}, + [2327] = {.lex_state = 734}, + [2328] = {.lex_state = 734, .external_lex_state = 1}, + [2329] = {.lex_state = 734}, + [2330] = {.lex_state = 734}, + [2331] = {.lex_state = 734}, + [2332] = {.lex_state = 734}, + [2333] = {.lex_state = 734}, + [2334] = {.lex_state = 58}, + [2335] = {.lex_state = 734}, + [2336] = {.lex_state = 734}, + [2337] = {.lex_state = 734}, + [2338] = {.lex_state = 734}, + [2339] = {.lex_state = 734}, + [2340] = {.lex_state = 734}, + [2341] = {.lex_state = 734}, + [2342] = {.lex_state = 734}, + [2343] = {.lex_state = 734}, + [2344] = {.lex_state = 734}, + [2345] = {.lex_state = 734}, + [2346] = {.lex_state = 734, .external_lex_state = 1}, + [2347] = {.lex_state = 734}, + [2348] = {.lex_state = 734}, + [2349] = {.lex_state = 734}, + [2350] = {.lex_state = 734}, + [2351] = {.lex_state = 734}, + [2352] = {.lex_state = 734}, + [2353] = {.lex_state = 734}, + [2354] = {.lex_state = 734}, + [2355] = {.lex_state = 734}, + [2356] = {.lex_state = 734}, + [2357] = {.lex_state = 734}, + [2358] = {.lex_state = 734}, + [2359] = {.lex_state = 734}, + [2360] = {.lex_state = 734}, + [2361] = {.lex_state = 734}, + [2362] = {.lex_state = 734}, + [2363] = {.lex_state = 734}, + [2364] = {.lex_state = 734}, + [2365] = {.lex_state = 67}, + [2366] = {.lex_state = 734}, + [2367] = {.lex_state = 734}, + [2368] = {.lex_state = 734}, + [2369] = {.lex_state = 105}, + [2370] = {.lex_state = 58}, + [2371] = {.lex_state = 734}, + [2372] = {.lex_state = 734}, + [2373] = {.lex_state = 734}, + [2374] = {.lex_state = 734}, + [2375] = {.lex_state = 58}, + [2376] = {.lex_state = 58}, + [2377] = {.lex_state = 734}, + [2378] = {.lex_state = 734}, + [2379] = {.lex_state = 67}, + [2380] = {.lex_state = 734}, + [2381] = {.lex_state = 105}, + [2382] = {.lex_state = 58}, + [2383] = {.lex_state = 67}, + [2384] = {.lex_state = 734}, + [2385] = {.lex_state = 734}, + [2386] = {.lex_state = 67}, + [2387] = {.lex_state = 734}, + [2388] = {.lex_state = 58}, + [2389] = {.lex_state = 734}, + [2390] = {.lex_state = 734}, + [2391] = {.lex_state = 734}, + [2392] = {.lex_state = 58}, + [2393] = {.lex_state = 734}, + [2394] = {.lex_state = 734}, + [2395] = {.lex_state = 734}, + [2396] = {.lex_state = 734}, + [2397] = {.lex_state = 734}, + [2398] = {.lex_state = 734}, + [2399] = {.lex_state = 734}, + [2400] = {.lex_state = 734}, + [2401] = {.lex_state = 734}, + [2402] = {.lex_state = 734}, + [2403] = {.lex_state = 734}, + [2404] = {.lex_state = 734}, + [2405] = {.lex_state = 734}, + [2406] = {.lex_state = 734}, + [2407] = {.lex_state = 67}, + [2408] = {.lex_state = 734}, + [2409] = {.lex_state = 734}, + [2410] = {.lex_state = 734}, + [2411] = {.lex_state = 734}, + [2412] = {.lex_state = 58}, + [2413] = {.lex_state = 734}, + [2414] = {.lex_state = 734}, + [2415] = {.lex_state = 734}, + [2416] = {.lex_state = 105}, + [2417] = {.lex_state = 734}, + [2418] = {.lex_state = 105}, + [2419] = {.lex_state = 50}, + [2420] = {.lex_state = 734}, + [2421] = {.lex_state = 734}, + [2422] = {.lex_state = 734}, + [2423] = {.lex_state = 101}, + [2424] = {.lex_state = 734}, + [2425] = {.lex_state = 734}, + [2426] = {.lex_state = 734}, + [2427] = {.lex_state = 734}, + [2428] = {.lex_state = 734}, + [2429] = {.lex_state = 734}, + [2430] = {.lex_state = 55}, + [2431] = {.lex_state = 55}, + [2432] = {.lex_state = 734}, + [2433] = {.lex_state = 734}, + [2434] = {.lex_state = 734}, + [2435] = {.lex_state = 734}, + [2436] = {.lex_state = 734}, + [2437] = {.lex_state = 57}, + [2438] = {.lex_state = 55}, + [2439] = {.lex_state = 734}, + [2440] = {.lex_state = 57}, + [2441] = {.lex_state = 55}, + [2442] = {.lex_state = 50}, + [2443] = {.lex_state = 734}, + [2444] = {.lex_state = 50}, + [2445] = {.lex_state = 50}, + [2446] = {.lex_state = 50}, + [2447] = {.lex_state = 50}, + [2448] = {.lex_state = 50}, + [2449] = {.lex_state = 55}, + [2450] = {.lex_state = 57}, + [2451] = {.lex_state = 734}, + [2452] = {.lex_state = 105}, + [2453] = {.lex_state = 734}, + [2454] = {.lex_state = 101}, + [2455] = {.lex_state = 57}, + [2456] = {.lex_state = 57}, + [2457] = {.lex_state = 55}, + [2458] = {.lex_state = 57}, + [2459] = {.lex_state = 55}, + [2460] = {.lex_state = 55}, + [2461] = {.lex_state = 734}, + [2462] = {.lex_state = 101}, + [2463] = {.lex_state = 50}, + [2464] = {.lex_state = 734}, + [2465] = {.lex_state = 105}, + [2466] = {.lex_state = 734}, + [2467] = {.lex_state = 734}, + [2468] = {.lex_state = 60}, + [2469] = {.lex_state = 734}, + [2470] = {.lex_state = 57}, + [2471] = {.lex_state = 55}, + [2472] = {.lex_state = 57}, + [2473] = {.lex_state = 55}, + [2474] = {.lex_state = 57}, + [2475] = {.lex_state = 55}, + [2476] = {.lex_state = 734}, + [2477] = {.lex_state = 734}, + [2478] = {.lex_state = 55}, + [2479] = {.lex_state = 57}, + [2480] = {.lex_state = 734}, + [2481] = {.lex_state = 734}, + [2482] = {.lex_state = 60}, + [2483] = {.lex_state = 60}, + [2484] = {.lex_state = 57}, + [2485] = {.lex_state = 734}, + [2486] = {.lex_state = 55}, + [2487] = {.lex_state = 58}, + [2488] = {.lex_state = 55}, + [2489] = {.lex_state = 57}, + [2490] = {.lex_state = 55}, + [2491] = {.lex_state = 57}, + [2492] = {.lex_state = 734}, + [2493] = {.lex_state = 734}, + [2494] = {.lex_state = 734}, + [2495] = {.lex_state = 734}, + [2496] = {.lex_state = 106}, + [2497] = {.lex_state = 734}, + [2498] = {.lex_state = 734}, + [2499] = {.lex_state = 734}, + [2500] = {.lex_state = 734}, + [2501] = {.lex_state = 734}, + [2502] = {.lex_state = 734}, + [2503] = {.lex_state = 734}, + [2504] = {.lex_state = 734}, + [2505] = {.lex_state = 734}, + [2506] = {.lex_state = 734}, + [2507] = {.lex_state = 734}, + [2508] = {.lex_state = 734}, + [2509] = {.lex_state = 734}, + [2510] = {.lex_state = 734}, + [2511] = {.lex_state = 734}, + [2512] = {.lex_state = 734}, + [2513] = {.lex_state = 50}, + [2514] = {.lex_state = 108}, + [2515] = {.lex_state = 734}, + [2516] = {.lex_state = 734}, [2517] = {.lex_state = 100}, - [2518] = {.lex_state = 642}, - [2519] = {.lex_state = 642}, - [2520] = {.lex_state = 642}, - [2521] = {.lex_state = 642}, - [2522] = {.lex_state = 642}, - [2523] = {.lex_state = 642}, - [2524] = {.lex_state = 642}, - [2525] = {.lex_state = 642}, - [2526] = {.lex_state = 642}, - [2527] = {.lex_state = 642}, - [2528] = {.lex_state = 642}, - [2529] = {.lex_state = 642}, - [2530] = {.lex_state = 642}, - [2531] = {.lex_state = 642}, - [2532] = {.lex_state = 642, .external_lex_state = 1}, - [2533] = {.lex_state = 642}, - [2534] = {.lex_state = 642}, - [2535] = {.lex_state = 50}, - [2536] = {.lex_state = 642}, - [2537] = {.lex_state = 642, .external_lex_state = 1}, - [2538] = {.lex_state = 50}, - [2539] = {.lex_state = 642}, - [2540] = {.lex_state = 642}, - [2541] = {.lex_state = 642}, - [2542] = {.lex_state = 642}, - [2543] = {.lex_state = 642}, - [2544] = {.lex_state = 642, .external_lex_state = 1}, - [2545] = {.lex_state = 642}, - [2546] = {.lex_state = 642}, - [2547] = {.lex_state = 642}, - [2548] = {.lex_state = 642}, - [2549] = {.lex_state = 642}, - [2550] = {.lex_state = 642}, - [2551] = {.lex_state = 642}, - [2552] = {.lex_state = 642}, - [2553] = {.lex_state = 642}, - [2554] = {.lex_state = 642}, - [2555] = {.lex_state = 642}, - [2556] = {.lex_state = 56}, - [2557] = {.lex_state = 642}, - [2558] = {.lex_state = 642}, - [2559] = {.lex_state = 41}, - [2560] = {.lex_state = 642}, - [2561] = {.lex_state = 642}, - [2562] = {.lex_state = 50}, - [2563] = {.lex_state = 642}, - [2564] = {.lex_state = 50}, - [2565] = {.lex_state = 50}, - [2566] = {.lex_state = 642}, - [2567] = {.lex_state = 642}, - [2568] = {.lex_state = 50}, - [2569] = {.lex_state = 50}, - [2570] = {.lex_state = 50}, - [2571] = {.lex_state = 50}, - [2572] = {.lex_state = 642}, - [2573] = {.lex_state = 642}, - [2574] = {.lex_state = 642}, - [2575] = {.lex_state = 642}, - [2576] = {.lex_state = 642}, - [2577] = {.lex_state = 50}, - [2578] = {.lex_state = 642}, - [2579] = {.lex_state = 50}, - [2580] = {.lex_state = 642}, - [2581] = {.lex_state = 642}, - [2582] = {.lex_state = 50}, - [2583] = {.lex_state = 642}, - [2584] = {.lex_state = 642}, - [2585] = {.lex_state = 50}, - [2586] = {.lex_state = 642}, - [2587] = {.lex_state = 642}, - [2588] = {.lex_state = 642}, - [2589] = {.lex_state = 50}, - [2590] = {.lex_state = 642}, - [2591] = {.lex_state = 642}, - [2592] = {.lex_state = 642}, - [2593] = {.lex_state = 642}, - [2594] = {.lex_state = 642}, - [2595] = {.lex_state = 642}, - [2596] = {.lex_state = 50}, - [2597] = {.lex_state = 642}, - [2598] = {.lex_state = 50}, - [2599] = {.lex_state = 642}, - [2600] = {.lex_state = 50}, - [2601] = {.lex_state = 642}, - [2602] = {.lex_state = 642}, - [2603] = {.lex_state = 642}, - [2604] = {.lex_state = 642}, - [2605] = {.lex_state = 60}, - [2606] = {.lex_state = 642}, - [2607] = {.lex_state = 642}, - [2608] = {.lex_state = 642}, - [2609] = {.lex_state = 50}, - [2610] = {.lex_state = 642}, - [2611] = {.lex_state = 50}, - [2612] = {.lex_state = 642}, - [2613] = {.lex_state = 642}, - [2614] = {.lex_state = 50}, - [2615] = {.lex_state = 642}, - [2616] = {.lex_state = 50}, - [2617] = {.lex_state = 48}, - [2618] = {.lex_state = 642}, - [2619] = {.lex_state = 642}, - [2620] = {.lex_state = 642}, - [2621] = {.lex_state = 642}, - [2622] = {.lex_state = 642}, - [2623] = {.lex_state = 642}, - [2624] = {.lex_state = 642}, - [2625] = {.lex_state = 642}, - [2626] = {.lex_state = 642}, - [2627] = {.lex_state = 642}, - [2628] = {.lex_state = 642}, - [2629] = {.lex_state = 50}, - [2630] = {.lex_state = 50}, - [2631] = {.lex_state = 50}, - [2632] = {.lex_state = 642}, - [2633] = {.lex_state = 50}, - [2634] = {.lex_state = 50}, - [2635] = {.lex_state = 642}, - [2636] = {.lex_state = 642}, - [2637] = {.lex_state = 642}, - [2638] = {.lex_state = 642}, - [2639] = {.lex_state = 642}, - [2640] = {.lex_state = 642}, - [2641] = {.lex_state = 60}, - [2642] = {.lex_state = 642}, - [2643] = {.lex_state = 642}, - [2644] = {.lex_state = 642}, - [2645] = {.lex_state = 642}, - [2646] = {.lex_state = 642}, - [2647] = {.lex_state = 48}, - [2648] = {.lex_state = 642}, - [2649] = {.lex_state = 642}, - [2650] = {.lex_state = 50}, - [2651] = {.lex_state = 50}, - [2652] = {.lex_state = 642}, - [2653] = {.lex_state = 642}, - [2654] = {.lex_state = 50}, - [2655] = {.lex_state = 50}, - [2656] = {.lex_state = 642}, - [2657] = {.lex_state = 642}, - [2658] = {.lex_state = 642}, - [2659] = {.lex_state = 50}, - [2660] = {.lex_state = 642}, - [2661] = {.lex_state = 642}, - [2662] = {.lex_state = 50}, - [2663] = {.lex_state = 642}, - [2664] = {.lex_state = 50}, - [2665] = {.lex_state = 42}, - [2666] = {.lex_state = 50}, - [2667] = {.lex_state = 50}, - [2668] = {.lex_state = 50}, - [2669] = {.lex_state = 50}, - [2670] = {.lex_state = 50}, - [2671] = {.lex_state = 642}, - [2672] = {.lex_state = 642}, - [2673] = {.lex_state = 642}, - [2674] = {.lex_state = 642}, - [2675] = {.lex_state = 50}, - [2676] = {.lex_state = 642}, - [2677] = {.lex_state = 642}, - [2678] = {.lex_state = 642}, - [2679] = {.lex_state = 642}, - [2680] = {.lex_state = 642}, - [2681] = {.lex_state = 50}, - [2682] = {.lex_state = 642}, - [2683] = {.lex_state = 50}, - [2684] = {.lex_state = 50}, - [2685] = {.lex_state = 642}, - [2686] = {.lex_state = 642}, - [2687] = {.lex_state = 642}, - [2688] = {.lex_state = 50}, + [2518] = {.lex_state = 734}, + [2519] = {.lex_state = 734}, + [2520] = {.lex_state = 56}, + [2521] = {.lex_state = 50}, + [2522] = {.lex_state = 734}, + [2523] = {.lex_state = 106}, + [2524] = {.lex_state = 93}, + [2525] = {.lex_state = 734}, + [2526] = {.lex_state = 50}, + [2527] = {.lex_state = 734, .external_lex_state = 1}, + [2528] = {.lex_state = 734, .external_lex_state = 1}, + [2529] = {.lex_state = 93}, + [2530] = {.lex_state = 106}, + [2531] = {.lex_state = 734}, + [2532] = {.lex_state = 734}, + [2533] = {.lex_state = 46}, + [2534] = {.lex_state = 734}, + [2535] = {.lex_state = 734}, + [2536] = {.lex_state = 734, .external_lex_state = 1}, + [2537] = {.lex_state = 734}, + [2538] = {.lex_state = 56}, + [2539] = {.lex_state = 734}, + [2540] = {.lex_state = 50}, + [2541] = {.lex_state = 734}, + [2542] = {.lex_state = 106}, + [2543] = {.lex_state = 50}, + [2544] = {.lex_state = 734, .external_lex_state = 1}, + [2545] = {.lex_state = 56}, + [2546] = {.lex_state = 734}, + [2547] = {.lex_state = 734}, + [2548] = {.lex_state = 734}, + [2549] = {.lex_state = 734}, + [2550] = {.lex_state = 734}, + [2551] = {.lex_state = 734}, + [2552] = {.lex_state = 734}, + [2553] = {.lex_state = 734}, + [2554] = {.lex_state = 734}, + [2555] = {.lex_state = 734}, + [2556] = {.lex_state = 734}, + [2557] = {.lex_state = 93}, + [2558] = {.lex_state = 734}, + [2559] = {.lex_state = 734}, + [2560] = {.lex_state = 734}, + [2561] = {.lex_state = 734}, + [2562] = {.lex_state = 734}, + [2563] = {.lex_state = 734}, + [2564] = {.lex_state = 734}, + [2565] = {.lex_state = 734}, + [2566] = {.lex_state = 734}, + [2567] = {.lex_state = 734}, + [2568] = {.lex_state = 734}, + [2569] = {.lex_state = 734}, + [2570] = {.lex_state = 734}, + [2571] = {.lex_state = 734}, + [2572] = {.lex_state = 734}, + [2573] = {.lex_state = 734}, + [2574] = {.lex_state = 734}, + [2575] = {.lex_state = 93}, + [2576] = {.lex_state = 734}, + [2577] = {.lex_state = 734}, + [2578] = {.lex_state = 734}, + [2579] = {.lex_state = 43}, + [2580] = {.lex_state = 734}, + [2581] = {.lex_state = 734}, + [2582] = {.lex_state = 734}, + [2583] = {.lex_state = 734}, + [2584] = {.lex_state = 734}, + [2585] = {.lex_state = 734}, + [2586] = {.lex_state = 734}, + [2587] = {.lex_state = 734}, + [2588] = {.lex_state = 734}, + [2589] = {.lex_state = 734}, + [2590] = {.lex_state = 734}, + [2591] = {.lex_state = 734}, + [2592] = {.lex_state = 734}, + [2593] = {.lex_state = 734}, + [2594] = {.lex_state = 734}, + [2595] = {.lex_state = 734}, + [2596] = {.lex_state = 734}, + [2597] = {.lex_state = 734}, + [2598] = {.lex_state = 734}, + [2599] = {.lex_state = 734}, + [2600] = {.lex_state = 734}, + [2601] = {.lex_state = 734}, + [2602] = {.lex_state = 734}, + [2603] = {.lex_state = 734}, + [2604] = {.lex_state = 734}, + [2605] = {.lex_state = 734}, + [2606] = {.lex_state = 734}, + [2607] = {.lex_state = 734}, + [2608] = {.lex_state = 734}, + [2609] = {.lex_state = 734}, + [2610] = {.lex_state = 734, .external_lex_state = 1}, + [2611] = {.lex_state = 734}, + [2612] = {.lex_state = 734}, + [2613] = {.lex_state = 734}, + [2614] = {.lex_state = 734}, + [2615] = {.lex_state = 734}, + [2616] = {.lex_state = 734, .external_lex_state = 1}, + [2617] = {.lex_state = 734}, + [2618] = {.lex_state = 734}, + [2619] = {.lex_state = 734}, + [2620] = {.lex_state = 734}, + [2621] = {.lex_state = 734}, + [2622] = {.lex_state = 734}, + [2623] = {.lex_state = 734}, + [2624] = {.lex_state = 734}, + [2625] = {.lex_state = 734}, + [2626] = {.lex_state = 734}, + [2627] = {.lex_state = 734}, + [2628] = {.lex_state = 734}, + [2629] = {.lex_state = 734}, + [2630] = {.lex_state = 734}, + [2631] = {.lex_state = 734}, + [2632] = {.lex_state = 734}, + [2633] = {.lex_state = 734}, + [2634] = {.lex_state = 734}, + [2635] = {.lex_state = 108}, + [2636] = {.lex_state = 734}, + [2637] = {.lex_state = 734, .external_lex_state = 1}, + [2638] = {.lex_state = 50, .external_lex_state = 1}, + [2639] = {.lex_state = 734}, + [2640] = {.lex_state = 56}, + [2641] = {.lex_state = 734, .external_lex_state = 1}, + [2642] = {.lex_state = 43}, + [2643] = {.lex_state = 734}, + [2644] = {.lex_state = 734}, + [2645] = {.lex_state = 734}, + [2646] = {.lex_state = 734}, + [2647] = {.lex_state = 734}, + [2648] = {.lex_state = 734}, + [2649] = {.lex_state = 734}, + [2650] = {.lex_state = 734}, + [2651] = {.lex_state = 734}, + [2652] = {.lex_state = 734}, + [2653] = {.lex_state = 734}, + [2654] = {.lex_state = 734}, + [2655] = {.lex_state = 734}, + [2656] = {.lex_state = 734}, + [2657] = {.lex_state = 734}, + [2658] = {.lex_state = 734}, + [2659] = {.lex_state = 734}, + [2660] = {.lex_state = 734}, + [2661] = {.lex_state = 734}, + [2662] = {.lex_state = 734}, + [2663] = {.lex_state = 734}, + [2664] = {.lex_state = 734}, + [2665] = {.lex_state = 734}, + [2666] = {.lex_state = 734}, + [2667] = {.lex_state = 734}, + [2668] = {.lex_state = 734}, + [2669] = {.lex_state = 734}, + [2670] = {.lex_state = 734}, + [2671] = {.lex_state = 734}, + [2672] = {.lex_state = 734}, + [2673] = {.lex_state = 734}, + [2674] = {.lex_state = 734}, + [2675] = {.lex_state = 734}, + [2676] = {.lex_state = 734}, + [2677] = {.lex_state = 734}, + [2678] = {.lex_state = 734}, + [2679] = {.lex_state = 734}, + [2680] = {.lex_state = 734}, + [2681] = {.lex_state = 734}, + [2682] = {.lex_state = 734}, + [2683] = {.lex_state = 734}, + [2684] = {.lex_state = 734}, + [2685] = {.lex_state = 734}, + [2686] = {.lex_state = 734}, + [2687] = {.lex_state = 100}, + [2688] = {.lex_state = 734}, [2689] = {.lex_state = 50}, - [2690] = {.lex_state = 642}, - [2691] = {.lex_state = 642}, - [2692] = {.lex_state = 642}, - [2693] = {.lex_state = 642}, - [2694] = {.lex_state = 642}, - [2695] = {.lex_state = 642}, - [2696] = {.lex_state = 642}, - [2697] = {.lex_state = 642}, - [2698] = {.lex_state = 642}, - [2699] = {.lex_state = 642}, - [2700] = {.lex_state = 642}, - [2701] = {.lex_state = 642}, - [2702] = {.lex_state = 642}, - [2703] = {.lex_state = 642}, - [2704] = {.lex_state = 642}, - [2705] = {.lex_state = 642}, - [2706] = {.lex_state = 642}, - [2707] = {.lex_state = 642}, - [2708] = {.lex_state = 642}, - [2709] = {.lex_state = 48}, - [2710] = {.lex_state = 642}, - [2711] = {.lex_state = 642}, - [2712] = {.lex_state = 642}, - [2713] = {.lex_state = 642}, - [2714] = {.lex_state = 642}, - [2715] = {.lex_state = 642}, - [2716] = {.lex_state = 642}, - [2717] = {.lex_state = 642}, - [2718] = {.lex_state = 642}, - [2719] = {.lex_state = 642}, - [2720] = {.lex_state = 50}, - [2721] = {.lex_state = 642}, - [2722] = {.lex_state = 642}, - [2723] = {.lex_state = 50}, - [2724] = {.lex_state = 642}, - [2725] = {.lex_state = 642}, - [2726] = {.lex_state = 642}, - [2727] = {.lex_state = 50}, - [2728] = {.lex_state = 642}, - [2729] = {.lex_state = 50}, - [2730] = {.lex_state = 642}, - [2731] = {.lex_state = 642}, - [2732] = {.lex_state = 642}, - [2733] = {.lex_state = 642}, - [2734] = {.lex_state = 60}, - [2735] = {.lex_state = 50}, - [2736] = {.lex_state = 642}, - [2737] = {.lex_state = 642}, - [2738] = {.lex_state = 48}, - [2739] = {.lex_state = 642, .external_lex_state = 1}, - [2740] = {.lex_state = 642}, - [2741] = {.lex_state = 642}, - [2742] = {.lex_state = 642}, - [2743] = {.lex_state = 642}, - [2744] = {.lex_state = 642}, - [2745] = {.lex_state = 642}, - [2746] = {.lex_state = 642}, - [2747] = {.lex_state = 642}, - [2748] = {.lex_state = 642}, - [2749] = {.lex_state = 642}, - [2750] = {.lex_state = 642}, - [2751] = {.lex_state = 642}, - [2752] = {.lex_state = 642}, - [2753] = {.lex_state = 642}, - [2754] = {.lex_state = 642}, - [2755] = {.lex_state = 642}, - [2756] = {.lex_state = 642}, - [2757] = {.lex_state = 642}, - [2758] = {.lex_state = 642}, - [2759] = {.lex_state = 642}, - [2760] = {.lex_state = 642}, - [2761] = {.lex_state = 642}, - [2762] = {.lex_state = 642}, - [2763] = {.lex_state = 642}, - [2764] = {.lex_state = 642}, - [2765] = {.lex_state = 642}, - [2766] = {.lex_state = 642}, - [2767] = {.lex_state = 642}, - [2768] = {.lex_state = 642}, - [2769] = {.lex_state = 642}, - [2770] = {.lex_state = 642}, - [2771] = {.lex_state = 642}, - [2772] = {.lex_state = 642}, - [2773] = {.lex_state = 642}, - [2774] = {.lex_state = 642}, - [2775] = {.lex_state = 50}, - [2776] = {.lex_state = 50}, - [2777] = {.lex_state = 642}, - [2778] = {.lex_state = 60}, - [2779] = {.lex_state = 642}, - [2780] = {.lex_state = 642}, - [2781] = {.lex_state = 642}, - [2782] = {.lex_state = 642}, - [2783] = {.lex_state = 48}, - [2784] = {.lex_state = 642}, - [2785] = {.lex_state = 50}, - [2786] = {.lex_state = 42}, - [2787] = {.lex_state = 642}, - [2788] = {.lex_state = 642}, - [2789] = {.lex_state = 642}, + [2690] = {.lex_state = 50, .external_lex_state = 1}, + [2691] = {.lex_state = 734}, + [2692] = {.lex_state = 734}, + [2693] = {.lex_state = 734}, + [2694] = {.lex_state = 106}, + [2695] = {.lex_state = 734}, + [2696] = {.lex_state = 50}, + [2697] = {.lex_state = 734}, + [2698] = {.lex_state = 734}, + [2699] = {.lex_state = 734}, + [2700] = {.lex_state = 734}, + [2701] = {.lex_state = 50}, + [2702] = {.lex_state = 43}, + [2703] = {.lex_state = 734}, + [2704] = {.lex_state = 734}, + [2705] = {.lex_state = 734}, + [2706] = {.lex_state = 734}, + [2707] = {.lex_state = 734}, + [2708] = {.lex_state = 734, .external_lex_state = 1}, + [2709] = {.lex_state = 734}, + [2710] = {.lex_state = 734}, + [2711] = {.lex_state = 734}, + [2712] = {.lex_state = 734}, + [2713] = {.lex_state = 734, .external_lex_state = 1}, + [2714] = {.lex_state = 734, .external_lex_state = 1}, + [2715] = {.lex_state = 734}, + [2716] = {.lex_state = 56}, + [2717] = {.lex_state = 734}, + [2718] = {.lex_state = 734}, + [2719] = {.lex_state = 734}, + [2720] = {.lex_state = 734}, + [2721] = {.lex_state = 734}, + [2722] = {.lex_state = 734}, + [2723] = {.lex_state = 734}, + [2724] = {.lex_state = 734}, + [2725] = {.lex_state = 734}, + [2726] = {.lex_state = 734}, + [2727] = {.lex_state = 734}, + [2728] = {.lex_state = 734}, + [2729] = {.lex_state = 734}, + [2730] = {.lex_state = 734}, + [2731] = {.lex_state = 734}, + [2732] = {.lex_state = 734}, + [2733] = {.lex_state = 734}, + [2734] = {.lex_state = 734}, + [2735] = {.lex_state = 734}, + [2736] = {.lex_state = 734}, + [2737] = {.lex_state = 734}, + [2738] = {.lex_state = 734}, + [2739] = {.lex_state = 734}, + [2740] = {.lex_state = 734}, + [2741] = {.lex_state = 50}, + [2742] = {.lex_state = 734}, + [2743] = {.lex_state = 734}, + [2744] = {.lex_state = 734}, + [2745] = {.lex_state = 734}, + [2746] = {.lex_state = 734}, + [2747] = {.lex_state = 734}, + [2748] = {.lex_state = 734}, + [2749] = {.lex_state = 734}, + [2750] = {.lex_state = 734}, + [2751] = {.lex_state = 734}, + [2752] = {.lex_state = 734}, + [2753] = {.lex_state = 734}, + [2754] = {.lex_state = 734}, + [2755] = {.lex_state = 734, .external_lex_state = 1}, + [2756] = {.lex_state = 734}, + [2757] = {.lex_state = 734}, + [2758] = {.lex_state = 734}, + [2759] = {.lex_state = 734}, + [2760] = {.lex_state = 734}, + [2761] = {.lex_state = 734}, + [2762] = {.lex_state = 734}, + [2763] = {.lex_state = 734}, + [2764] = {.lex_state = 734}, + [2765] = {.lex_state = 734}, + [2766] = {.lex_state = 734}, + [2767] = {.lex_state = 734}, + [2768] = {.lex_state = 734}, + [2769] = {.lex_state = 734}, + [2770] = {.lex_state = 734}, + [2771] = {.lex_state = 50}, + [2772] = {.lex_state = 734}, + [2773] = {.lex_state = 734}, + [2774] = {.lex_state = 734}, + [2775] = {.lex_state = 734}, + [2776] = {.lex_state = 734}, + [2777] = {.lex_state = 734}, + [2778] = {.lex_state = 734}, + [2779] = {.lex_state = 734}, + [2780] = {.lex_state = 734}, + [2781] = {.lex_state = 734}, + [2782] = {.lex_state = 734}, + [2783] = {.lex_state = 734, .external_lex_state = 1}, + [2784] = {.lex_state = 734}, + [2785] = {.lex_state = 734}, + [2786] = {.lex_state = 734}, + [2787] = {.lex_state = 734}, + [2788] = {.lex_state = 734}, + [2789] = {.lex_state = 734}, [2790] = {.lex_state = 50}, - [2791] = {.lex_state = 50}, - [2792] = {.lex_state = 642}, - [2793] = {.lex_state = 642}, - [2794] = {.lex_state = 642}, - [2795] = {.lex_state = 99}, - [2796] = {.lex_state = 50}, - [2797] = {.lex_state = 642}, - [2798] = {.lex_state = 50}, - [2799] = {.lex_state = 50}, - [2800] = {.lex_state = 50}, - [2801] = {.lex_state = 642}, - [2802] = {.lex_state = 642}, - [2803] = {.lex_state = 642}, - [2804] = {.lex_state = 642}, - [2805] = {.lex_state = 642}, - [2806] = {.lex_state = 642}, - [2807] = {.lex_state = 642}, - [2808] = {.lex_state = 642}, - [2809] = {.lex_state = 642}, - [2810] = {.lex_state = 642}, - [2811] = {.lex_state = 642}, - [2812] = {.lex_state = 642}, - [2813] = {.lex_state = 642}, - [2814] = {.lex_state = 642}, - [2815] = {.lex_state = 642}, - [2816] = {.lex_state = 642}, - [2817] = {.lex_state = 642}, - [2818] = {.lex_state = 642}, - [2819] = {.lex_state = 642}, - [2820] = {.lex_state = 642}, - [2821] = {.lex_state = 642}, - [2822] = {.lex_state = 642}, - [2823] = {.lex_state = 642}, - [2824] = {.lex_state = 642}, - [2825] = {.lex_state = 642}, - [2826] = {.lex_state = 642}, - [2827] = {.lex_state = 642}, - [2828] = {.lex_state = 642}, - [2829] = {.lex_state = 642}, - [2830] = {.lex_state = 642}, - [2831] = {.lex_state = 642}, - [2832] = {.lex_state = 642}, - [2833] = {.lex_state = 642}, - [2834] = {.lex_state = 642}, - [2835] = {.lex_state = 642}, - [2836] = {.lex_state = 642}, - [2837] = {.lex_state = 642}, - [2838] = {.lex_state = 642}, - [2839] = {.lex_state = 642}, - [2840] = {.lex_state = 642}, - [2841] = {.lex_state = 642}, - [2842] = {.lex_state = 99}, - [2843] = {.lex_state = 50}, - [2844] = {.lex_state = 642}, - [2845] = {.lex_state = 642}, - [2846] = {.lex_state = 642}, - [2847] = {.lex_state = 642}, - [2848] = {.lex_state = 50}, - [2849] = {.lex_state = 642}, - [2850] = {.lex_state = 642}, - [2851] = {.lex_state = 642}, - [2852] = {.lex_state = 642}, - [2853] = {.lex_state = 50}, - [2854] = {.lex_state = 642}, - [2855] = {.lex_state = 642}, - [2856] = {.lex_state = 50}, - [2857] = {.lex_state = 642}, - [2858] = {.lex_state = 642}, - [2859] = {.lex_state = 642}, - [2860] = {.lex_state = 642}, - [2861] = {.lex_state = 642}, - [2862] = {.lex_state = 642}, - [2863] = {.lex_state = 642}, - [2864] = {.lex_state = 642}, - [2865] = {.lex_state = 642}, - [2866] = {.lex_state = 642}, - [2867] = {.lex_state = 642}, - [2868] = {.lex_state = 642}, - [2869] = {.lex_state = 642}, - [2870] = {.lex_state = 642}, - [2871] = {.lex_state = 642}, - [2872] = {.lex_state = 642}, - [2873] = {.lex_state = 642}, - [2874] = {.lex_state = 50}, - [2875] = {.lex_state = 642}, - [2876] = {.lex_state = 642}, - [2877] = {.lex_state = 642}, - [2878] = {.lex_state = 642}, - [2879] = {.lex_state = 642}, - [2880] = {.lex_state = 642}, - [2881] = {.lex_state = 642}, - [2882] = {.lex_state = 642}, - [2883] = {.lex_state = 642}, - [2884] = {.lex_state = 642}, - [2885] = {.lex_state = 642}, - [2886] = {.lex_state = 642}, - [2887] = {.lex_state = 42}, - [2888] = {.lex_state = 41}, - [2889] = {.lex_state = 642}, - [2890] = {.lex_state = 642}, - [2891] = {.lex_state = 50}, - [2892] = {.lex_state = 642}, - [2893] = {.lex_state = 642, .external_lex_state = 1}, - [2894] = {.lex_state = 642}, - [2895] = {.lex_state = 642}, - [2896] = {.lex_state = 642}, - [2897] = {.lex_state = 642}, - [2898] = {.lex_state = 642}, - [2899] = {.lex_state = 642}, - [2900] = {.lex_state = 642}, - [2901] = {.lex_state = 642}, - [2902] = {.lex_state = 642}, - [2903] = {.lex_state = 642}, - [2904] = {.lex_state = 50}, - [2905] = {.lex_state = 642}, - [2906] = {.lex_state = 642}, - [2907] = {.lex_state = 50}, - [2908] = {.lex_state = 642}, - [2909] = {.lex_state = 42}, - [2910] = {.lex_state = 642}, - [2911] = {.lex_state = 642}, - [2912] = {.lex_state = 50}, - [2913] = {.lex_state = 642}, - [2914] = {.lex_state = 642}, - [2915] = {.lex_state = 642}, - [2916] = {.lex_state = 642}, - [2917] = {.lex_state = 642}, - [2918] = {.lex_state = 642}, - [2919] = {.lex_state = 642}, - [2920] = {.lex_state = 642}, + [2791] = {.lex_state = 56}, + [2792] = {.lex_state = 734}, + [2793] = {.lex_state = 734}, + [2794] = {.lex_state = 734}, + [2795] = {.lex_state = 734}, + [2796] = {.lex_state = 734}, + [2797] = {.lex_state = 734}, + [2798] = {.lex_state = 734}, + [2799] = {.lex_state = 734}, + [2800] = {.lex_state = 734}, + [2801] = {.lex_state = 734}, + [2802] = {.lex_state = 734, .external_lex_state = 1}, + [2803] = {.lex_state = 734}, + [2804] = {.lex_state = 734}, + [2805] = {.lex_state = 734}, + [2806] = {.lex_state = 734}, + [2807] = {.lex_state = 734}, + [2808] = {.lex_state = 734}, + [2809] = {.lex_state = 734}, + [2810] = {.lex_state = 734}, + [2811] = {.lex_state = 734}, + [2812] = {.lex_state = 68}, + [2813] = {.lex_state = 734}, + [2814] = {.lex_state = 734}, + [2815] = {.lex_state = 734, .external_lex_state = 1}, + [2816] = {.lex_state = 734}, + [2817] = {.lex_state = 734}, + [2818] = {.lex_state = 734}, + [2819] = {.lex_state = 734}, + [2820] = {.lex_state = 734}, + [2821] = {.lex_state = 734}, + [2822] = {.lex_state = 734}, + [2823] = {.lex_state = 734}, + [2824] = {.lex_state = 106}, + [2825] = {.lex_state = 734}, + [2826] = {.lex_state = 50}, + [2827] = {.lex_state = 734}, + [2828] = {.lex_state = 734}, + [2829] = {.lex_state = 734}, + [2830] = {.lex_state = 734}, + [2831] = {.lex_state = 734}, + [2832] = {.lex_state = 734}, + [2833] = {.lex_state = 734}, + [2834] = {.lex_state = 734}, + [2835] = {.lex_state = 734}, + [2836] = {.lex_state = 734}, + [2837] = {.lex_state = 734}, + [2838] = {.lex_state = 734}, + [2839] = {.lex_state = 734}, + [2840] = {.lex_state = 734}, + [2841] = {.lex_state = 734}, + [2842] = {.lex_state = 734}, + [2843] = {.lex_state = 734}, + [2844] = {.lex_state = 734, .external_lex_state = 1}, + [2845] = {.lex_state = 734}, + [2846] = {.lex_state = 734}, + [2847] = {.lex_state = 43}, + [2848] = {.lex_state = 734}, + [2849] = {.lex_state = 734}, + [2850] = {.lex_state = 734}, + [2851] = {.lex_state = 734}, + [2852] = {.lex_state = 734}, + [2853] = {.lex_state = 108}, + [2854] = {.lex_state = 734}, + [2855] = {.lex_state = 734}, + [2856] = {.lex_state = 43}, + [2857] = {.lex_state = 734}, + [2858] = {.lex_state = 734}, + [2859] = {.lex_state = 46}, + [2860] = {.lex_state = 734}, + [2861] = {.lex_state = 734}, + [2862] = {.lex_state = 734}, + [2863] = {.lex_state = 734, .external_lex_state = 1}, + [2864] = {.lex_state = 734}, + [2865] = {.lex_state = 734}, + [2866] = {.lex_state = 734}, + [2867] = {.lex_state = 734}, + [2868] = {.lex_state = 734}, + [2869] = {.lex_state = 734}, + [2870] = {.lex_state = 108}, + [2871] = {.lex_state = 734}, + [2872] = {.lex_state = 734}, + [2873] = {.lex_state = 734}, + [2874] = {.lex_state = 734}, + [2875] = {.lex_state = 734}, + [2876] = {.lex_state = 106}, + [2877] = {.lex_state = 734}, + [2878] = {.lex_state = 734}, + [2879] = {.lex_state = 57}, + [2880] = {.lex_state = 734}, + [2881] = {.lex_state = 734}, + [2882] = {.lex_state = 55}, + [2883] = {.lex_state = 734, .external_lex_state = 1}, + [2884] = {.lex_state = 734}, + [2885] = {.lex_state = 734}, + [2886] = {.lex_state = 734}, + [2887] = {.lex_state = 734}, + [2888] = {.lex_state = 734}, + [2889] = {.lex_state = 56}, + [2890] = {.lex_state = 734}, + [2891] = {.lex_state = 734}, + [2892] = {.lex_state = 734}, + [2893] = {.lex_state = 734}, + [2894] = {.lex_state = 734}, + [2895] = {.lex_state = 734}, + [2896] = {.lex_state = 734}, + [2897] = {.lex_state = 50}, + [2898] = {.lex_state = 734}, + [2899] = {.lex_state = 734, .external_lex_state = 1}, + [2900] = {.lex_state = 734}, + [2901] = {.lex_state = 734}, + [2902] = {.lex_state = 106}, + [2903] = {.lex_state = 734}, + [2904] = {.lex_state = 734}, + [2905] = {.lex_state = 734}, + [2906] = {.lex_state = 734}, + [2907] = {.lex_state = 734}, + [2908] = {.lex_state = 734}, + [2909] = {.lex_state = 734}, + [2910] = {.lex_state = 734}, + [2911] = {.lex_state = 734}, + [2912] = {.lex_state = 734}, + [2913] = {.lex_state = 50}, + [2914] = {.lex_state = 50}, + [2915] = {.lex_state = 734}, + [2916] = {.lex_state = 734}, + [2917] = {.lex_state = 734}, + [2918] = {.lex_state = 92}, + [2919] = {.lex_state = 734}, + [2920] = {.lex_state = 734}, [2921] = {.lex_state = 50}, - [2922] = {.lex_state = 50}, - [2923] = {.lex_state = 642}, - [2924] = {.lex_state = 642}, - [2925] = {.lex_state = 642}, - [2926] = {.lex_state = 642}, - [2927] = {.lex_state = 50}, - [2928] = {.lex_state = 642}, - [2929] = {.lex_state = 642}, - [2930] = {.lex_state = 642}, - [2931] = {.lex_state = 48}, - [2932] = {.lex_state = 50}, - [2933] = {.lex_state = 642}, - [2934] = {.lex_state = 48}, - [2935] = {.lex_state = 642}, - [2936] = {.lex_state = 642}, - [2937] = {.lex_state = 50}, - [2938] = {.lex_state = 48}, - [2939] = {.lex_state = 50}, - [2940] = {.lex_state = 642}, - [2941] = {.lex_state = 48}, - [2942] = {.lex_state = 48}, - [2943] = {.lex_state = 642}, - [2944] = {.lex_state = 642}, - [2945] = {.lex_state = 642}, - [2946] = {.lex_state = 642}, - [2947] = {.lex_state = 642}, - [2948] = {.lex_state = 642}, - [2949] = {.lex_state = 642}, - [2950] = {.lex_state = 642}, - [2951] = {.lex_state = 642}, - [2952] = {.lex_state = 642}, - [2953] = {.lex_state = 642}, - [2954] = {.lex_state = 642}, - [2955] = {.lex_state = 642}, - [2956] = {.lex_state = 642}, - [2957] = {.lex_state = 642}, - [2958] = {.lex_state = 642}, - [2959] = {.lex_state = 642}, - [2960] = {.lex_state = 642}, - [2961] = {.lex_state = 642}, - [2962] = {.lex_state = 642}, - [2963] = {.lex_state = 642}, - [2964] = {.lex_state = 642}, - [2965] = {.lex_state = 642}, - [2966] = {.lex_state = 642}, - [2967] = {.lex_state = 642}, - [2968] = {.lex_state = 642}, - [2969] = {.lex_state = 642}, - [2970] = {.lex_state = 642}, - [2971] = {.lex_state = 642}, - [2972] = {.lex_state = 50}, - [2973] = {.lex_state = 642}, - [2974] = {.lex_state = 642}, - [2975] = {.lex_state = 642}, + [2922] = {.lex_state = 734}, + [2923] = {.lex_state = 734}, + [2924] = {.lex_state = 734}, + [2925] = {.lex_state = 50}, + [2926] = {.lex_state = 734}, + [2927] = {.lex_state = 734}, + [2928] = {.lex_state = 734}, + [2929] = {.lex_state = 734}, + [2930] = {.lex_state = 734}, + [2931] = {.lex_state = 734}, + [2932] = {.lex_state = 734}, + [2933] = {.lex_state = 734}, + [2934] = {.lex_state = 734}, + [2935] = {.lex_state = 734}, + [2936] = {.lex_state = 734}, + [2937] = {.lex_state = 734}, + [2938] = {.lex_state = 734}, + [2939] = {.lex_state = 734}, + [2940] = {.lex_state = 734}, + [2941] = {.lex_state = 734}, + [2942] = {.lex_state = 734}, + [2943] = {.lex_state = 734}, + [2944] = {.lex_state = 734}, + [2945] = {.lex_state = 734}, + [2946] = {.lex_state = 734}, + [2947] = {.lex_state = 50}, + [2948] = {.lex_state = 734}, + [2949] = {.lex_state = 734}, + [2950] = {.lex_state = 734}, + [2951] = {.lex_state = 734}, + [2952] = {.lex_state = 734}, + [2953] = {.lex_state = 734}, + [2954] = {.lex_state = 734}, + [2955] = {.lex_state = 734}, + [2956] = {.lex_state = 50}, + [2957] = {.lex_state = 734}, + [2958] = {.lex_state = 734}, + [2959] = {.lex_state = 91}, + [2960] = {.lex_state = 734}, + [2961] = {.lex_state = 734}, + [2962] = {.lex_state = 734}, + [2963] = {.lex_state = 50}, + [2964] = {.lex_state = 50}, + [2965] = {.lex_state = 734}, + [2966] = {.lex_state = 50}, + [2967] = {.lex_state = 734}, + [2968] = {.lex_state = 91}, + [2969] = {.lex_state = 734}, + [2970] = {.lex_state = 734}, + [2971] = {.lex_state = 734}, + [2972] = {.lex_state = 734}, + [2973] = {.lex_state = 734}, + [2974] = {.lex_state = 734}, + [2975] = {.lex_state = 734}, [2976] = {.lex_state = 50}, - [2977] = {.lex_state = 642}, - [2978] = {.lex_state = 642}, - [2979] = {.lex_state = 642}, - [2980] = {.lex_state = 642}, - [2981] = {.lex_state = 642}, - [2982] = {.lex_state = 642}, + [2977] = {.lex_state = 50}, + [2978] = {.lex_state = 734}, + [2979] = {.lex_state = 734}, + [2980] = {.lex_state = 50}, + [2981] = {.lex_state = 734}, + [2982] = {.lex_state = 734}, [2983] = {.lex_state = 50}, - [2984] = {.lex_state = 642}, - [2985] = {.lex_state = 642}, - [2986] = {.lex_state = 642}, - [2987] = {.lex_state = 642}, - [2988] = {.lex_state = 642}, - [2989] = {.lex_state = 642}, - [2990] = {.lex_state = 642}, - [2991] = {.lex_state = 50}, - [2992] = {.lex_state = 642}, - [2993] = {.lex_state = 642}, - [2994] = {.lex_state = 642}, + [2984] = {.lex_state = 106}, + [2985] = {.lex_state = 734}, + [2986] = {.lex_state = 50}, + [2987] = {.lex_state = 734, .external_lex_state = 1}, + [2988] = {.lex_state = 50}, + [2989] = {.lex_state = 734}, + [2990] = {.lex_state = 734}, + [2991] = {.lex_state = 734}, + [2992] = {.lex_state = 734}, + [2993] = {.lex_state = 50}, + [2994] = {.lex_state = 734}, [2995] = {.lex_state = 50}, - [2996] = {.lex_state = 642}, - [2997] = {.lex_state = 642}, - [2998] = {.lex_state = 642}, - [2999] = {.lex_state = 642}, - [3000] = {.lex_state = 642}, - [3001] = {.lex_state = 642}, - [3002] = {.lex_state = 50}, - [3003] = {.lex_state = 642}, - [3004] = {.lex_state = 642}, - [3005] = {.lex_state = 48}, - [3006] = {.lex_state = 642}, - [3007] = {.lex_state = 642}, - [3008] = {.lex_state = 642}, - [3009] = {.lex_state = 642}, - [3010] = {.lex_state = 50}, - [3011] = {.lex_state = 642}, - [3012] = {.lex_state = 642}, - [3013] = {.lex_state = 642}, - [3014] = {.lex_state = 642}, - [3015] = {.lex_state = 642}, - [3016] = {.lex_state = 642}, - [3017] = {.lex_state = 50}, - [3018] = {.lex_state = 50}, - [3019] = {.lex_state = 642}, - [3020] = {.lex_state = 642}, - [3021] = {.lex_state = 642}, - [3022] = {.lex_state = 642}, - [3023] = {.lex_state = 642}, - [3024] = {.lex_state = 642}, - [3025] = {.lex_state = 642}, - [3026] = {.lex_state = 642}, - [3027] = {.lex_state = 642}, - [3028] = {.lex_state = 642}, - [3029] = {.lex_state = 642}, - [3030] = {.lex_state = 642}, - [3031] = {.lex_state = 48}, - [3032] = {.lex_state = 642}, - [3033] = {.lex_state = 642}, - [3034] = {.lex_state = 50}, - [3035] = {.lex_state = 642}, - [3036] = {.lex_state = 50}, - [3037] = {.lex_state = 642}, - [3038] = {.lex_state = 642}, - [3039] = {.lex_state = 642}, - [3040] = {.lex_state = 50}, - [3041] = {.lex_state = 642}, - [3042] = {.lex_state = 642}, - [3043] = {.lex_state = 642}, - [3044] = {.lex_state = 642}, - [3045] = {.lex_state = 642}, - [3046] = {.lex_state = 642}, - [3047] = {.lex_state = 642}, - [3048] = {.lex_state = 642}, - [3049] = {.lex_state = 642}, - [3050] = {.lex_state = 642}, - [3051] = {.lex_state = 642}, - [3052] = {.lex_state = 642}, - [3053] = {.lex_state = 642}, - [3054] = {.lex_state = 642}, - [3055] = {.lex_state = 642}, - [3056] = {.lex_state = 642}, - [3057] = {.lex_state = 642}, - [3058] = {.lex_state = 642}, - [3059] = {.lex_state = 642}, - [3060] = {.lex_state = 642}, - [3061] = {.lex_state = 642}, - [3062] = {.lex_state = 642}, - [3063] = {.lex_state = 50}, - [3064] = {.lex_state = 642}, - [3065] = {.lex_state = 642}, - [3066] = {.lex_state = 642}, - [3067] = {.lex_state = 642}, - [3068] = {.lex_state = 642}, - [3069] = {.lex_state = 642}, - [3070] = {.lex_state = 642}, - [3071] = {.lex_state = 642}, - [3072] = {.lex_state = 642}, - [3073] = {.lex_state = 642}, - [3074] = {.lex_state = 642}, - [3075] = {.lex_state = 642}, - [3076] = {.lex_state = 642}, - [3077] = {.lex_state = 642}, - [3078] = {.lex_state = 642}, - [3079] = {.lex_state = 642}, - [3080] = {.lex_state = 642}, - [3081] = {.lex_state = 50}, - [3082] = {.lex_state = 642}, - [3083] = {.lex_state = 642}, - [3084] = {.lex_state = 642}, - [3085] = {.lex_state = 642}, - [3086] = {.lex_state = 642}, - [3087] = {.lex_state = 642}, - [3088] = {.lex_state = 642}, - [3089] = {.lex_state = 48}, - [3090] = {.lex_state = 642}, - [3091] = {.lex_state = 642}, - [3092] = {.lex_state = 642}, - [3093] = {.lex_state = 642}, - [3094] = {.lex_state = 642}, - [3095] = {.lex_state = 642}, - [3096] = {.lex_state = 642}, - [3097] = {.lex_state = 642}, - [3098] = {.lex_state = 642}, - [3099] = {.lex_state = 642}, - [3100] = {.lex_state = 642}, - [3101] = {.lex_state = 642}, - [3102] = {.lex_state = 642}, - [3103] = {.lex_state = 642}, - [3104] = {.lex_state = 642}, - [3105] = {.lex_state = 50}, - [3106] = {.lex_state = 50}, + [2996] = {.lex_state = 50}, + [2997] = {.lex_state = 50}, + [2998] = {.lex_state = 734}, + [2999] = {.lex_state = 50}, + [3000] = {.lex_state = 50}, + [3001] = {.lex_state = 50}, + [3002] = {.lex_state = 734}, + [3003] = {.lex_state = 734}, + [3004] = {.lex_state = 50}, + [3005] = {.lex_state = 50}, + [3006] = {.lex_state = 734}, + [3007] = {.lex_state = 734}, + [3008] = {.lex_state = 734}, + [3009] = {.lex_state = 50}, + [3010] = {.lex_state = 91}, + [3011] = {.lex_state = 50}, + [3012] = {.lex_state = 50}, + [3013] = {.lex_state = 50}, + [3014] = {.lex_state = 734}, + [3015] = {.lex_state = 734}, + [3016] = {.lex_state = 734}, + [3017] = {.lex_state = 734}, + [3018] = {.lex_state = 734}, + [3019] = {.lex_state = 50}, + [3020] = {.lex_state = 50}, + [3021] = {.lex_state = 734}, + [3022] = {.lex_state = 734}, + [3023] = {.lex_state = 734}, + [3024] = {.lex_state = 734}, + [3025] = {.lex_state = 734}, + [3026] = {.lex_state = 734}, + [3027] = {.lex_state = 50}, + [3028] = {.lex_state = 734}, + [3029] = {.lex_state = 50}, + [3030] = {.lex_state = 734}, + [3031] = {.lex_state = 50}, + [3032] = {.lex_state = 50}, + [3033] = {.lex_state = 734}, + [3034] = {.lex_state = 734}, + [3035] = {.lex_state = 50}, + [3036] = {.lex_state = 734}, + [3037] = {.lex_state = 734}, + [3038] = {.lex_state = 50}, + [3039] = {.lex_state = 50}, + [3040] = {.lex_state = 734}, + [3041] = {.lex_state = 734}, + [3042] = {.lex_state = 734}, + [3043] = {.lex_state = 734}, + [3044] = {.lex_state = 734}, + [3045] = {.lex_state = 734}, + [3046] = {.lex_state = 734}, + [3047] = {.lex_state = 50}, + [3048] = {.lex_state = 734}, + [3049] = {.lex_state = 50}, + [3050] = {.lex_state = 734}, + [3051] = {.lex_state = 734}, + [3052] = {.lex_state = 50}, + [3053] = {.lex_state = 734}, + [3054] = {.lex_state = 734}, + [3055] = {.lex_state = 734}, + [3056] = {.lex_state = 50}, + [3057] = {.lex_state = 734}, + [3058] = {.lex_state = 58}, + [3059] = {.lex_state = 50}, + [3060] = {.lex_state = 734}, + [3061] = {.lex_state = 734}, + [3062] = {.lex_state = 50}, + [3063] = {.lex_state = 734}, + [3064] = {.lex_state = 50}, + [3065] = {.lex_state = 50}, + [3066] = {.lex_state = 734}, + [3067] = {.lex_state = 734}, + [3068] = {.lex_state = 50}, + [3069] = {.lex_state = 734}, + [3070] = {.lex_state = 50}, + [3071] = {.lex_state = 734}, + [3072] = {.lex_state = 50}, + [3073] = {.lex_state = 734}, + [3074] = {.lex_state = 734}, + [3075] = {.lex_state = 734}, + [3076] = {.lex_state = 734}, + [3077] = {.lex_state = 734}, + [3078] = {.lex_state = 734}, + [3079] = {.lex_state = 734}, + [3080] = {.lex_state = 734}, + [3081] = {.lex_state = 734}, + [3082] = {.lex_state = 734}, + [3083] = {.lex_state = 50}, + [3084] = {.lex_state = 50}, + [3085] = {.lex_state = 734, .external_lex_state = 1}, + [3086] = {.lex_state = 734}, + [3087] = {.lex_state = 734}, + [3088] = {.lex_state = 734}, + [3089] = {.lex_state = 734}, + [3090] = {.lex_state = 734}, + [3091] = {.lex_state = 43}, + [3092] = {.lex_state = 734}, + [3093] = {.lex_state = 734}, + [3094] = {.lex_state = 734}, + [3095] = {.lex_state = 91}, + [3096] = {.lex_state = 734}, + [3097] = {.lex_state = 58}, + [3098] = {.lex_state = 734}, + [3099] = {.lex_state = 734}, + [3100] = {.lex_state = 734}, + [3101] = {.lex_state = 734}, + [3102] = {.lex_state = 50}, + [3103] = {.lex_state = 734}, + [3104] = {.lex_state = 734}, + [3105] = {.lex_state = 734}, + [3106] = {.lex_state = 734}, [3107] = {.lex_state = 50}, - [3108] = {.lex_state = 642}, - [3109] = {.lex_state = 642}, - [3110] = {.lex_state = 642}, - [3111] = {.lex_state = 642}, - [3112] = {.lex_state = 48}, - [3113] = {.lex_state = 642}, - [3114] = {.lex_state = 642}, - [3115] = {.lex_state = 642}, - [3116] = {.lex_state = 642}, - [3117] = {.lex_state = 642}, - [3118] = {.lex_state = 642}, - [3119] = {.lex_state = 642}, - [3120] = {.lex_state = 642}, - [3121] = {.lex_state = 642}, - [3122] = {.lex_state = 642}, - [3123] = {.lex_state = 642}, - [3124] = {.lex_state = 50}, - [3125] = {.lex_state = 642}, - [3126] = {.lex_state = 642}, - [3127] = {.lex_state = 642}, - [3128] = {.lex_state = 642}, - [3129] = {.lex_state = 642}, - [3130] = {.lex_state = 642}, - [3131] = {.lex_state = 642}, - [3132] = {.lex_state = 642}, - [3133] = {.lex_state = 50}, - [3134] = {.lex_state = 642}, - [3135] = {.lex_state = 642}, - [3136] = {.lex_state = 642}, - [3137] = {.lex_state = 642}, - [3138] = {.lex_state = 642}, - [3139] = {.lex_state = 48}, - [3140] = {.lex_state = 642}, - [3141] = {.lex_state = 642}, - [3142] = {.lex_state = 642}, - [3143] = {.lex_state = 642}, - [3144] = {.lex_state = 642}, - [3145] = {.lex_state = 48}, - [3146] = {.lex_state = 642}, - [3147] = {.lex_state = 48}, - [3148] = {.lex_state = 48}, - [3149] = {.lex_state = 642}, - [3150] = {.lex_state = 50}, - [3151] = {.lex_state = 50}, - [3152] = {.lex_state = 50}, - [3153] = {.lex_state = 642}, - [3154] = {.lex_state = 642}, + [3108] = {.lex_state = 50}, + [3109] = {.lex_state = 734}, + [3110] = {.lex_state = 734}, + [3111] = {.lex_state = 734}, + [3112] = {.lex_state = 734}, + [3113] = {.lex_state = 58}, + [3114] = {.lex_state = 734}, + [3115] = {.lex_state = 734}, + [3116] = {.lex_state = 734}, + [3117] = {.lex_state = 734}, + [3118] = {.lex_state = 734}, + [3119] = {.lex_state = 91}, + [3120] = {.lex_state = 734}, + [3121] = {.lex_state = 734}, + [3122] = {.lex_state = 734}, + [3123] = {.lex_state = 734}, + [3124] = {.lex_state = 734}, + [3125] = {.lex_state = 734}, + [3126] = {.lex_state = 50}, + [3127] = {.lex_state = 734}, + [3128] = {.lex_state = 734}, + [3129] = {.lex_state = 50}, + [3130] = {.lex_state = 734}, + [3131] = {.lex_state = 50}, + [3132] = {.lex_state = 734}, + [3133] = {.lex_state = 734}, + [3134] = {.lex_state = 50}, + [3135] = {.lex_state = 734}, + [3136] = {.lex_state = 734}, + [3137] = {.lex_state = 734}, + [3138] = {.lex_state = 50}, + [3139] = {.lex_state = 734}, + [3140] = {.lex_state = 734}, + [3141] = {.lex_state = 734}, + [3142] = {.lex_state = 734}, + [3143] = {.lex_state = 734}, + [3144] = {.lex_state = 734}, + [3145] = {.lex_state = 734}, + [3146] = {.lex_state = 734}, + [3147] = {.lex_state = 734}, + [3148] = {.lex_state = 50}, + [3149] = {.lex_state = 50}, + [3150] = {.lex_state = 734}, + [3151] = {.lex_state = 734}, + [3152] = {.lex_state = 734}, + [3153] = {.lex_state = 46}, + [3154] = {.lex_state = 734}, [3155] = {.lex_state = 50}, - [3156] = {.lex_state = 642}, - [3157] = {.lex_state = 642}, - [3158] = {.lex_state = 642}, - [3159] = {.lex_state = 642}, - [3160] = {.lex_state = 642}, - [3161] = {.lex_state = 642}, - [3162] = {.lex_state = 642}, - [3163] = {.lex_state = 642}, - [3164] = {.lex_state = 642}, - [3165] = {.lex_state = 642}, - [3166] = {.lex_state = 642}, - [3167] = {.lex_state = 642}, - [3168] = {.lex_state = 50}, - [3169] = {.lex_state = 642}, - [3170] = {.lex_state = 50}, - [3171] = {.lex_state = 642}, - [3172] = {.lex_state = 642}, - [3173] = {.lex_state = 642}, - [3174] = {.lex_state = 50}, - [3175] = {.lex_state = 50}, - [3176] = {.lex_state = 642}, - [3177] = {.lex_state = 642}, + [3156] = {.lex_state = 734}, + [3157] = {.lex_state = 734}, + [3158] = {.lex_state = 50}, + [3159] = {.lex_state = 734}, + [3160] = {.lex_state = 734}, + [3161] = {.lex_state = 734}, + [3162] = {.lex_state = 734}, + [3163] = {.lex_state = 50}, + [3164] = {.lex_state = 50}, + [3165] = {.lex_state = 734}, + [3166] = {.lex_state = 734}, + [3167] = {.lex_state = 734}, + [3168] = {.lex_state = 734}, + [3169] = {.lex_state = 50}, + [3170] = {.lex_state = 734}, + [3171] = {.lex_state = 734}, + [3172] = {.lex_state = 734}, + [3173] = {.lex_state = 734}, + [3174] = {.lex_state = 734}, + [3175] = {.lex_state = 734}, + [3176] = {.lex_state = 734}, + [3177] = {.lex_state = 91}, [3178] = {.lex_state = 50}, - [3179] = {.lex_state = 50}, - [3180] = {.lex_state = 642}, - [3181] = {.lex_state = 642}, - [3182] = {.lex_state = 642}, - [3183] = {.lex_state = 642}, - [3184] = {.lex_state = 642}, - [3185] = {.lex_state = 50}, + [3179] = {.lex_state = 734}, + [3180] = {.lex_state = 734}, + [3181] = {.lex_state = 734}, + [3182] = {.lex_state = 734}, + [3183] = {.lex_state = 734}, + [3184] = {.lex_state = 58}, + [3185] = {.lex_state = 734}, [3186] = {.lex_state = 50}, - [3187] = {.lex_state = 642}, - [3188] = {.lex_state = 48}, - [3189] = {.lex_state = 48}, - [3190] = {.lex_state = 642}, - [3191] = {.lex_state = 48}, - [3192] = {.lex_state = 642}, - [3193] = {.lex_state = 642}, - [3194] = {.lex_state = 642}, - [3195] = {.lex_state = 642}, - [3196] = {.lex_state = 642}, + [3187] = {.lex_state = 734}, + [3188] = {.lex_state = 734}, + [3189] = {.lex_state = 734}, + [3190] = {.lex_state = 734}, + [3191] = {.lex_state = 734}, + [3192] = {.lex_state = 734}, + [3193] = {.lex_state = 734}, + [3194] = {.lex_state = 734}, + [3195] = {.lex_state = 734}, + [3196] = {.lex_state = 734}, [3197] = {.lex_state = 50}, - [3198] = {.lex_state = 642}, + [3198] = {.lex_state = 734}, [3199] = {.lex_state = 50}, - [3200] = {.lex_state = 48}, - [3201] = {.lex_state = 48}, - [3202] = {.lex_state = 642}, - [3203] = {.lex_state = 642}, - [3204] = {.lex_state = 642}, - [3205] = {.lex_state = 642}, - [3206] = {.lex_state = 642}, - [3207] = {.lex_state = 642}, - [3208] = {.lex_state = 642}, - [3209] = {.lex_state = 642}, - [3210] = {.lex_state = 642}, - [3211] = {.lex_state = 642}, - [3212] = {.lex_state = 642}, - [3213] = {.lex_state = 642}, - [3214] = {.lex_state = 642}, - [3215] = {.lex_state = 642}, - [3216] = {.lex_state = 50}, - [3217] = {.lex_state = 50}, - [3218] = {.lex_state = 642}, - [3219] = {.lex_state = 642}, - [3220] = {.lex_state = 642}, - [3221] = {.lex_state = 642}, - [3222] = {.lex_state = 642}, - [3223] = {.lex_state = 642}, - [3224] = {.lex_state = 642}, - [3225] = {.lex_state = 48}, - [3226] = {.lex_state = 50}, - [3227] = {.lex_state = 642}, - [3228] = {.lex_state = 50}, - [3229] = {.lex_state = 642}, - [3230] = {.lex_state = 50}, - [3231] = {.lex_state = 50}, - [3232] = {.lex_state = 50}, - [3233] = {.lex_state = 50}, - [3234] = {.lex_state = 50}, - [3235] = {.lex_state = 50}, - [3236] = {.lex_state = 642}, - [3237] = {.lex_state = 50}, - [3238] = {.lex_state = 642}, - [3239] = {.lex_state = 48}, - [3240] = {.lex_state = 50}, + [3200] = {.lex_state = 734}, + [3201] = {.lex_state = 734}, + [3202] = {.lex_state = 734}, + [3203] = {.lex_state = 734}, + [3204] = {.lex_state = 734}, + [3205] = {.lex_state = 734}, + [3206] = {.lex_state = 734}, + [3207] = {.lex_state = 50}, + [3208] = {.lex_state = 734}, + [3209] = {.lex_state = 43}, + [3210] = {.lex_state = 734}, + [3211] = {.lex_state = 734}, + [3212] = {.lex_state = 734}, + [3213] = {.lex_state = 734}, + [3214] = {.lex_state = 734}, + [3215] = {.lex_state = 50}, + [3216] = {.lex_state = 734}, + [3217] = {.lex_state = 734}, + [3218] = {.lex_state = 734}, + [3219] = {.lex_state = 734}, + [3220] = {.lex_state = 734}, + [3221] = {.lex_state = 734}, + [3222] = {.lex_state = 734}, + [3223] = {.lex_state = 734}, + [3224] = {.lex_state = 734}, + [3225] = {.lex_state = 734}, + [3226] = {.lex_state = 734}, + [3227] = {.lex_state = 734}, + [3228] = {.lex_state = 734}, + [3229] = {.lex_state = 734}, + [3230] = {.lex_state = 734}, + [3231] = {.lex_state = 734}, + [3232] = {.lex_state = 734}, + [3233] = {.lex_state = 734}, + [3234] = {.lex_state = 734}, + [3235] = {.lex_state = 734}, + [3236] = {.lex_state = 734}, + [3237] = {.lex_state = 734}, + [3238] = {.lex_state = 734}, + [3239] = {.lex_state = 50}, + [3240] = {.lex_state = 734}, [3241] = {.lex_state = 50}, - [3242] = {.lex_state = 50}, - [3243] = {.lex_state = 50}, - [3244] = {.lex_state = 642}, - [3245] = {.lex_state = 642}, - [3246] = {.lex_state = 642}, - [3247] = {.lex_state = 642}, - [3248] = {.lex_state = 642}, - [3249] = {.lex_state = 50}, - [3250] = {.lex_state = 642}, - [3251] = {.lex_state = 642}, - [3252] = {.lex_state = 642}, - [3253] = {.lex_state = 50}, - [3254] = {.lex_state = 50}, - [3255] = {.lex_state = 50}, - [3256] = {.lex_state = 642}, - [3257] = {.lex_state = 50}, - [3258] = {.lex_state = 642}, - [3259] = {.lex_state = 642}, + [3242] = {.lex_state = 734}, + [3243] = {.lex_state = 734}, + [3244] = {.lex_state = 50, .external_lex_state = 1}, + [3245] = {.lex_state = 734}, + [3246] = {.lex_state = 734}, + [3247] = {.lex_state = 734}, + [3248] = {.lex_state = 734}, + [3249] = {.lex_state = 734}, + [3250] = {.lex_state = 734}, + [3251] = {.lex_state = 734}, + [3252] = {.lex_state = 734}, + [3253] = {.lex_state = 734}, + [3254] = {.lex_state = 734}, + [3255] = {.lex_state = 734}, + [3256] = {.lex_state = 734}, + [3257] = {.lex_state = 734}, + [3258] = {.lex_state = 734}, + [3259] = {.lex_state = 50}, [3260] = {.lex_state = 50}, - [3261] = {.lex_state = 642}, - [3262] = {.lex_state = 642}, - [3263] = {.lex_state = 50}, - [3264] = {.lex_state = 655}, - [3265] = {.lex_state = 642}, - [3266] = {.lex_state = 50}, - [3267] = {.lex_state = 642}, - [3268] = {.lex_state = 642}, - [3269] = {.lex_state = 642}, - [3270] = {.lex_state = 642}, - [3271] = {.lex_state = 50}, - [3272] = {.lex_state = 642}, - [3273] = {.lex_state = 642}, - [3274] = {.lex_state = 642}, - [3275] = {.lex_state = 50}, - [3276] = {.lex_state = 642}, - [3277] = {.lex_state = 642}, - [3278] = {.lex_state = 642}, - [3279] = {.lex_state = 642}, - [3280] = {.lex_state = 642}, - [3281] = {.lex_state = 642}, - [3282] = {.lex_state = 642}, - [3283] = {.lex_state = 50}, + [3261] = {.lex_state = 734}, + [3262] = {.lex_state = 734}, + [3263] = {.lex_state = 734}, + [3264] = {.lex_state = 734}, + [3265] = {.lex_state = 734}, + [3266] = {.lex_state = 734}, + [3267] = {.lex_state = 734}, + [3268] = {.lex_state = 734}, + [3269] = {.lex_state = 734}, + [3270] = {.lex_state = 734}, + [3271] = {.lex_state = 734}, + [3272] = {.lex_state = 734}, + [3273] = {.lex_state = 734, .external_lex_state = 1}, + [3274] = {.lex_state = 734}, + [3275] = {.lex_state = 734}, + [3276] = {.lex_state = 734}, + [3277] = {.lex_state = 734}, + [3278] = {.lex_state = 734}, + [3279] = {.lex_state = 734}, + [3280] = {.lex_state = 734}, + [3281] = {.lex_state = 46}, + [3282] = {.lex_state = 50}, + [3283] = {.lex_state = 734}, [3284] = {.lex_state = 50}, - [3285] = {.lex_state = 50}, - [3286] = {.lex_state = 50}, + [3285] = {.lex_state = 734}, + [3286] = {.lex_state = 734}, [3287] = {.lex_state = 50}, [3288] = {.lex_state = 50}, - [3289] = {.lex_state = 50}, - [3290] = {.lex_state = 50}, - [3291] = {.lex_state = 642}, - [3292] = {.lex_state = 642}, - [3293] = {.lex_state = 50}, + [3289] = {.lex_state = 734}, + [3290] = {.lex_state = 734}, + [3291] = {.lex_state = 734}, + [3292] = {.lex_state = 103}, + [3293] = {.lex_state = 734}, [3294] = {.lex_state = 50}, - [3295] = {.lex_state = 642}, + [3295] = {.lex_state = 46}, [3296] = {.lex_state = 50}, - [3297] = {.lex_state = 642}, - [3298] = {.lex_state = 642}, - [3299] = {.lex_state = 50}, - [3300] = {.lex_state = 64}, - [3301] = {.lex_state = 642}, - [3302] = {.lex_state = 642}, - [3303] = {.lex_state = 642}, - [3304] = {.lex_state = 642}, - [3305] = {.lex_state = 642}, - [3306] = {.lex_state = 50}, - [3307] = {.lex_state = 642}, - [3308] = {.lex_state = 50}, - [3309] = {.lex_state = 642}, - [3310] = {.lex_state = 642}, - [3311] = {.lex_state = 50}, - [3312] = {.lex_state = 50}, - [3313] = {.lex_state = 102}, - [3314] = {(TSStateId)(-1)}, - [3315] = {(TSStateId)(-1)}, - [3316] = {(TSStateId)(-1)}, - [3317] = {(TSStateId)(-1)}, + [3297] = {.lex_state = 734}, + [3298] = {.lex_state = 103}, + [3299] = {.lex_state = 734}, + [3300] = {.lex_state = 734}, + [3301] = {.lex_state = 734}, + [3302] = {.lex_state = 50}, + [3303] = {.lex_state = 734}, + [3304] = {.lex_state = 734}, + [3305] = {.lex_state = 734}, + [3306] = {.lex_state = 734}, + [3307] = {.lex_state = 734}, + [3308] = {.lex_state = 734}, + [3309] = {.lex_state = 734}, + [3310] = {.lex_state = 50}, + [3311] = {.lex_state = 46}, + [3312] = {.lex_state = 734}, + [3313] = {.lex_state = 734}, + [3314] = {.lex_state = 734}, + [3315] = {.lex_state = 734}, + [3316] = {.lex_state = 734}, + [3317] = {.lex_state = 734}, + [3318] = {.lex_state = 734}, + [3319] = {.lex_state = 50}, + [3320] = {.lex_state = 734}, + [3321] = {.lex_state = 734}, + [3322] = {.lex_state = 734}, + [3323] = {.lex_state = 734}, + [3324] = {.lex_state = 734}, + [3325] = {.lex_state = 734}, + [3326] = {.lex_state = 50}, + [3327] = {.lex_state = 734}, + [3328] = {.lex_state = 734}, + [3329] = {.lex_state = 734}, + [3330] = {.lex_state = 734}, + [3331] = {.lex_state = 50}, + [3332] = {.lex_state = 734}, + [3333] = {.lex_state = 734}, + [3334] = {.lex_state = 734}, + [3335] = {.lex_state = 46}, + [3336] = {.lex_state = 734}, + [3337] = {.lex_state = 50}, + [3338] = {.lex_state = 50}, + [3339] = {.lex_state = 734}, + [3340] = {.lex_state = 734}, + [3341] = {.lex_state = 734}, + [3342] = {.lex_state = 734}, + [3343] = {.lex_state = 50}, + [3344] = {.lex_state = 734}, + [3345] = {.lex_state = 734}, + [3346] = {.lex_state = 734}, + [3347] = {.lex_state = 734}, + [3348] = {.lex_state = 734}, + [3349] = {.lex_state = 734}, + [3350] = {.lex_state = 734}, + [3351] = {.lex_state = 734}, + [3352] = {.lex_state = 106}, + [3353] = {.lex_state = 734}, + [3354] = {.lex_state = 734}, + [3355] = {.lex_state = 734}, + [3356] = {.lex_state = 734}, + [3357] = {.lex_state = 734}, + [3358] = {.lex_state = 734}, + [3359] = {.lex_state = 734}, + [3360] = {.lex_state = 734}, + [3361] = {.lex_state = 734}, + [3362] = {.lex_state = 734}, + [3363] = {.lex_state = 734}, + [3364] = {.lex_state = 734}, + [3365] = {.lex_state = 734}, + [3366] = {.lex_state = 734}, + [3367] = {.lex_state = 50}, + [3368] = {.lex_state = 734}, + [3369] = {.lex_state = 734}, + [3370] = {.lex_state = 50}, + [3371] = {.lex_state = 58}, + [3372] = {.lex_state = 734}, + [3373] = {.lex_state = 734}, + [3374] = {.lex_state = 734}, + [3375] = {.lex_state = 734}, + [3376] = {.lex_state = 734}, + [3377] = {.lex_state = 734}, + [3378] = {.lex_state = 734}, + [3379] = {.lex_state = 734}, + [3380] = {.lex_state = 734}, + [3381] = {.lex_state = 734}, + [3382] = {.lex_state = 734}, + [3383] = {.lex_state = 93}, + [3384] = {.lex_state = 734}, + [3385] = {.lex_state = 734}, + [3386] = {.lex_state = 734}, + [3387] = {.lex_state = 91}, + [3388] = {.lex_state = 734}, + [3389] = {.lex_state = 734}, + [3390] = {.lex_state = 734}, + [3391] = {.lex_state = 50}, + [3392] = {.lex_state = 734}, + [3393] = {.lex_state = 734}, + [3394] = {.lex_state = 734}, + [3395] = {.lex_state = 734}, + [3396] = {.lex_state = 734}, + [3397] = {.lex_state = 734}, + [3398] = {.lex_state = 734}, + [3399] = {.lex_state = 50}, + [3400] = {.lex_state = 50}, + [3401] = {.lex_state = 734}, + [3402] = {.lex_state = 734}, + [3403] = {.lex_state = 734}, + [3404] = {.lex_state = 50}, + [3405] = {.lex_state = 734}, + [3406] = {.lex_state = 734}, + [3407] = {.lex_state = 734}, + [3408] = {.lex_state = 734}, + [3409] = {.lex_state = 734}, + [3410] = {.lex_state = 91}, + [3411] = {.lex_state = 734}, + [3412] = {.lex_state = 734}, + [3413] = {.lex_state = 734}, + [3414] = {.lex_state = 734}, + [3415] = {.lex_state = 50}, + [3416] = {.lex_state = 734}, + [3417] = {.lex_state = 734}, + [3418] = {.lex_state = 734}, + [3419] = {.lex_state = 734}, + [3420] = {.lex_state = 734}, + [3421] = {.lex_state = 734}, + [3422] = {.lex_state = 734}, + [3423] = {.lex_state = 734}, + [3424] = {.lex_state = 734}, + [3425] = {.lex_state = 734}, + [3426] = {.lex_state = 50}, + [3427] = {.lex_state = 734}, + [3428] = {.lex_state = 734}, + [3429] = {.lex_state = 734}, + [3430] = {.lex_state = 734}, + [3431] = {.lex_state = 734}, + [3432] = {.lex_state = 734}, + [3433] = {.lex_state = 734}, + [3434] = {.lex_state = 734}, + [3435] = {.lex_state = 734}, + [3436] = {.lex_state = 734}, + [3437] = {.lex_state = 734}, + [3438] = {.lex_state = 50}, + [3439] = {.lex_state = 734}, + [3440] = {.lex_state = 734}, + [3441] = {.lex_state = 734}, + [3442] = {.lex_state = 734}, + [3443] = {.lex_state = 50}, + [3444] = {.lex_state = 734}, + [3445] = {.lex_state = 734}, + [3446] = {.lex_state = 734}, + [3447] = {.lex_state = 734}, + [3448] = {.lex_state = 734}, + [3449] = {.lex_state = 734}, + [3450] = {.lex_state = 734}, + [3451] = {.lex_state = 734}, + [3452] = {.lex_state = 734}, + [3453] = {.lex_state = 734}, + [3454] = {.lex_state = 734}, + [3455] = {.lex_state = 734}, + [3456] = {.lex_state = 734}, + [3457] = {.lex_state = 46}, + [3458] = {.lex_state = 734}, + [3459] = {.lex_state = 734}, + [3460] = {.lex_state = 734}, + [3461] = {.lex_state = 734}, + [3462] = {.lex_state = 734}, + [3463] = {.lex_state = 734}, + [3464] = {.lex_state = 91}, + [3465] = {.lex_state = 734}, + [3466] = {.lex_state = 734}, + [3467] = {.lex_state = 734}, + [3468] = {.lex_state = 734}, + [3469] = {.lex_state = 734}, + [3470] = {.lex_state = 50}, + [3471] = {.lex_state = 734}, + [3472] = {.lex_state = 734}, + [3473] = {.lex_state = 734}, + [3474] = {.lex_state = 734}, + [3475] = {.lex_state = 50}, + [3476] = {.lex_state = 50}, + [3477] = {.lex_state = 734}, + [3478] = {.lex_state = 50}, + [3479] = {.lex_state = 734}, + [3480] = {.lex_state = 734}, + [3481] = {.lex_state = 734}, + [3482] = {.lex_state = 734}, + [3483] = {.lex_state = 50}, + [3484] = {.lex_state = 734}, + [3485] = {.lex_state = 734}, + [3486] = {.lex_state = 734}, + [3487] = {.lex_state = 734}, + [3488] = {.lex_state = 734}, + [3489] = {.lex_state = 93}, + [3490] = {.lex_state = 50}, + [3491] = {.lex_state = 734}, + [3492] = {.lex_state = 50}, + [3493] = {.lex_state = 734}, + [3494] = {.lex_state = 734}, + [3495] = {.lex_state = 50}, + [3496] = {.lex_state = 734}, + [3497] = {.lex_state = 734}, + [3498] = {.lex_state = 734}, + [3499] = {.lex_state = 50}, + [3500] = {.lex_state = 734}, + [3501] = {.lex_state = 50}, + [3502] = {.lex_state = 734}, + [3503] = {.lex_state = 91}, + [3504] = {.lex_state = 734}, + [3505] = {.lex_state = 734}, + [3506] = {.lex_state = 734}, + [3507] = {.lex_state = 734}, + [3508] = {.lex_state = 734}, + [3509] = {.lex_state = 50}, + [3510] = {.lex_state = 734}, + [3511] = {.lex_state = 734}, + [3512] = {.lex_state = 734}, + [3513] = {.lex_state = 734}, + [3514] = {.lex_state = 734}, + [3515] = {.lex_state = 50}, + [3516] = {.lex_state = 734}, + [3517] = {.lex_state = 93}, + [3518] = {.lex_state = 50}, + [3519] = {.lex_state = 734}, + [3520] = {.lex_state = 734}, + [3521] = {.lex_state = 734}, + [3522] = {.lex_state = 734}, + [3523] = {.lex_state = 50}, + [3524] = {.lex_state = 50}, + [3525] = {.lex_state = 734}, + [3526] = {.lex_state = 734}, + [3527] = {.lex_state = 734}, + [3528] = {.lex_state = 734}, + [3529] = {.lex_state = 734}, + [3530] = {.lex_state = 734}, + [3531] = {.lex_state = 50}, + [3532] = {.lex_state = 50}, + [3533] = {.lex_state = 50}, + [3534] = {.lex_state = 50}, + [3535] = {.lex_state = 50}, + [3536] = {.lex_state = 734}, + [3537] = {.lex_state = 734}, + [3538] = {.lex_state = 734}, + [3539] = {.lex_state = 734}, + [3540] = {.lex_state = 734}, + [3541] = {.lex_state = 734}, + [3542] = {.lex_state = 734}, + [3543] = {.lex_state = 734}, + [3544] = {.lex_state = 734}, + [3545] = {.lex_state = 734}, + [3546] = {.lex_state = 734}, + [3547] = {.lex_state = 734}, + [3548] = {.lex_state = 50}, + [3549] = {.lex_state = 734}, + [3550] = {.lex_state = 734}, + [3551] = {.lex_state = 734}, + [3552] = {.lex_state = 50}, + [3553] = {.lex_state = 734}, + [3554] = {.lex_state = 50}, + [3555] = {.lex_state = 93}, + [3556] = {.lex_state = 734}, + [3557] = {.lex_state = 50}, + [3558] = {.lex_state = 734}, + [3559] = {.lex_state = 734}, + [3560] = {.lex_state = 734}, + [3561] = {.lex_state = 734}, + [3562] = {.lex_state = 734}, + [3563] = {.lex_state = 734}, + [3564] = {.lex_state = 734}, + [3565] = {.lex_state = 734}, + [3566] = {.lex_state = 734}, + [3567] = {.lex_state = 734}, + [3568] = {.lex_state = 91}, + [3569] = {.lex_state = 734}, + [3570] = {.lex_state = 734}, + [3571] = {.lex_state = 734}, + [3572] = {.lex_state = 734}, + [3573] = {.lex_state = 50}, + [3574] = {.lex_state = 734}, + [3575] = {.lex_state = 50}, + [3576] = {.lex_state = 50}, + [3577] = {.lex_state = 734}, + [3578] = {.lex_state = 93}, + [3579] = {.lex_state = 734}, + [3580] = {.lex_state = 734}, + [3581] = {.lex_state = 734}, + [3582] = {.lex_state = 734}, + [3583] = {.lex_state = 734}, + [3584] = {.lex_state = 734}, + [3585] = {.lex_state = 734}, + [3586] = {.lex_state = 50}, + [3587] = {.lex_state = 734}, + [3588] = {.lex_state = 734}, + [3589] = {.lex_state = 734}, + [3590] = {.lex_state = 734}, + [3591] = {.lex_state = 50}, + [3592] = {.lex_state = 734}, + [3593] = {.lex_state = 734}, + [3594] = {.lex_state = 734}, + [3595] = {.lex_state = 734}, + [3596] = {.lex_state = 734}, + [3597] = {.lex_state = 734}, + [3598] = {.lex_state = 734}, + [3599] = {.lex_state = 91}, + [3600] = {.lex_state = 734}, + [3601] = {.lex_state = 734}, + [3602] = {.lex_state = 734}, + [3603] = {.lex_state = 734}, + [3604] = {.lex_state = 50}, + [3605] = {.lex_state = 734}, + [3606] = {.lex_state = 734}, + [3607] = {.lex_state = 734}, + [3608] = {.lex_state = 734}, + [3609] = {.lex_state = 734}, + [3610] = {.lex_state = 734}, + [3611] = {.lex_state = 50}, + [3612] = {.lex_state = 50}, + [3613] = {.lex_state = 734}, + [3614] = {.lex_state = 734}, + [3615] = {.lex_state = 734}, + [3616] = {.lex_state = 734}, + [3617] = {.lex_state = 93}, + [3618] = {.lex_state = 50}, + [3619] = {.lex_state = 734}, + [3620] = {.lex_state = 50}, + [3621] = {.lex_state = 734}, + [3622] = {.lex_state = 734}, + [3623] = {.lex_state = 93}, + [3624] = {.lex_state = 734}, + [3625] = {.lex_state = 734}, + [3626] = {.lex_state = 734}, + [3627] = {.lex_state = 50}, + [3628] = {.lex_state = 734}, + [3629] = {.lex_state = 50}, + [3630] = {.lex_state = 734}, + [3631] = {.lex_state = 734}, + [3632] = {.lex_state = 734}, + [3633] = {.lex_state = 734}, + [3634] = {.lex_state = 734}, + [3635] = {.lex_state = 734}, + [3636] = {.lex_state = 734}, + [3637] = {.lex_state = 734}, + [3638] = {.lex_state = 734}, + [3639] = {.lex_state = 734}, + [3640] = {.lex_state = 734}, + [3641] = {.lex_state = 734}, + [3642] = {.lex_state = 734}, + [3643] = {.lex_state = 734}, + [3644] = {.lex_state = 734}, + [3645] = {.lex_state = 734}, + [3646] = {.lex_state = 734}, + [3647] = {.lex_state = 734}, + [3648] = {.lex_state = 734}, + [3649] = {.lex_state = 734}, + [3650] = {.lex_state = 734}, + [3651] = {.lex_state = 734}, + [3652] = {.lex_state = 734}, + [3653] = {.lex_state = 50}, + [3654] = {.lex_state = 734}, + [3655] = {.lex_state = 734}, + [3656] = {.lex_state = 50}, + [3657] = {.lex_state = 50}, + [3658] = {.lex_state = 91}, + [3659] = {.lex_state = 734}, + [3660] = {.lex_state = 734}, + [3661] = {.lex_state = 734}, + [3662] = {.lex_state = 734}, + [3663] = {.lex_state = 50}, + [3664] = {.lex_state = 50}, + [3665] = {.lex_state = 734}, + [3666] = {.lex_state = 734}, + [3667] = {.lex_state = 734}, + [3668] = {.lex_state = 50}, + [3669] = {.lex_state = 50}, + [3670] = {.lex_state = 734}, + [3671] = {.lex_state = 734}, + [3672] = {.lex_state = 734}, + [3673] = {.lex_state = 734}, + [3674] = {.lex_state = 734}, + [3675] = {.lex_state = 734}, + [3676] = {.lex_state = 734}, + [3677] = {.lex_state = 50}, + [3678] = {.lex_state = 734}, + [3679] = {.lex_state = 734}, + [3680] = {.lex_state = 734}, + [3681] = {.lex_state = 734}, + [3682] = {.lex_state = 50}, + [3683] = {.lex_state = 734}, + [3684] = {.lex_state = 747}, + [3685] = {.lex_state = 50}, + [3686] = {.lex_state = 50}, + [3687] = {.lex_state = 734}, + [3688] = {.lex_state = 734}, + [3689] = {.lex_state = 734}, + [3690] = {.lex_state = 50}, + [3691] = {.lex_state = 50}, + [3692] = {.lex_state = 50}, + [3693] = {.lex_state = 734}, + [3694] = {.lex_state = 50}, + [3695] = {.lex_state = 50}, + [3696] = {.lex_state = 734}, + [3697] = {.lex_state = 50}, + [3698] = {.lex_state = 734}, + [3699] = {.lex_state = 50}, + [3700] = {.lex_state = 734}, + [3701] = {.lex_state = 734}, + [3702] = {.lex_state = 734}, + [3703] = {.lex_state = 50}, + [3704] = {.lex_state = 734}, + [3705] = {.lex_state = 93}, + [3706] = {.lex_state = 93}, + [3707] = {.lex_state = 734}, + [3708] = {.lex_state = 734}, + [3709] = {.lex_state = 50}, + [3710] = {.lex_state = 734}, + [3711] = {.lex_state = 734}, + [3712] = {.lex_state = 50}, + [3713] = {.lex_state = 50}, + [3714] = {.lex_state = 734}, + [3715] = {.lex_state = 734}, + [3716] = {.lex_state = 734}, + [3717] = {.lex_state = 93}, + [3718] = {.lex_state = 93}, + [3719] = {.lex_state = 734}, + [3720] = {.lex_state = 734}, + [3721] = {.lex_state = 734}, + [3722] = {.lex_state = 734}, + [3723] = {.lex_state = 734}, + [3724] = {.lex_state = 50}, + [3725] = {.lex_state = 734}, + [3726] = {.lex_state = 734}, + [3727] = {.lex_state = 50}, + [3728] = {.lex_state = 734}, + [3729] = {.lex_state = 734}, + [3730] = {.lex_state = 734}, + [3731] = {.lex_state = 734}, + [3732] = {.lex_state = 50}, + [3733] = {.lex_state = 50}, + [3734] = {.lex_state = 734}, + [3735] = {.lex_state = 734}, + [3736] = {.lex_state = 734}, + [3737] = {.lex_state = 734}, + [3738] = {.lex_state = 734}, + [3739] = {.lex_state = 734}, + [3740] = {.lex_state = 50}, + [3741] = {.lex_state = 93}, + [3742] = {.lex_state = 50}, + [3743] = {.lex_state = 734}, + [3744] = {.lex_state = 734}, + [3745] = {.lex_state = 50}, + [3746] = {.lex_state = 734}, + [3747] = {.lex_state = 50}, + [3748] = {.lex_state = 734}, + [3749] = {.lex_state = 734}, + [3750] = {.lex_state = 734}, + [3751] = {.lex_state = 734}, + [3752] = {.lex_state = 734}, + [3753] = {.lex_state = 50}, + [3754] = {.lex_state = 50}, + [3755] = {.lex_state = 50}, + [3756] = {.lex_state = 50}, + [3757] = {.lex_state = 734}, + [3758] = {.lex_state = 734}, + [3759] = {.lex_state = 734}, + [3760] = {.lex_state = 50}, + [3761] = {.lex_state = 50}, + [3762] = {.lex_state = 50}, + [3763] = {.lex_state = 50}, + [3764] = {.lex_state = 734}, + [3765] = {.lex_state = 734}, + [3766] = {.lex_state = 50}, + [3767] = {.lex_state = 734}, + [3768] = {.lex_state = 734}, + [3769] = {.lex_state = 734}, + [3770] = {.lex_state = 734}, + [3771] = {.lex_state = 50}, + [3772] = {.lex_state = 734}, + [3773] = {.lex_state = 734}, + [3774] = {.lex_state = 734}, + [3775] = {.lex_state = 734}, + [3776] = {.lex_state = 734}, + [3777] = {.lex_state = 734}, + [3778] = {.lex_state = 50}, + [3779] = {.lex_state = 734}, + [3780] = {.lex_state = 50}, + [3781] = {.lex_state = 734}, + [3782] = {.lex_state = 734}, + [3783] = {.lex_state = 734}, + [3784] = {.lex_state = 50}, + [3785] = {.lex_state = 734}, + [3786] = {.lex_state = 734}, + [3787] = {.lex_state = 734}, + [3788] = {.lex_state = 734}, + [3789] = {.lex_state = 734}, + [3790] = {.lex_state = 734}, + [3791] = {.lex_state = 50}, + [3792] = {.lex_state = 50}, + [3793] = {.lex_state = 50}, + [3794] = {.lex_state = 50}, + [3795] = {.lex_state = 734}, + [3796] = {.lex_state = 734}, + [3797] = {.lex_state = 734}, + [3798] = {.lex_state = 50}, + [3799] = {.lex_state = 734}, + [3800] = {.lex_state = 734}, + [3801] = {.lex_state = 734}, + [3802] = {.lex_state = 734}, + [3803] = {.lex_state = 734}, + [3804] = {.lex_state = 50}, + [3805] = {.lex_state = 734}, + [3806] = {.lex_state = 734}, + [3807] = {.lex_state = 110}, + [3808] = {.lex_state = 64}, + [3809] = {.lex_state = 50}, + [3810] = {(TSStateId)(-1)}, + [3811] = {(TSStateId)(-1)}, + [3812] = {(TSStateId)(-1)}, + [3813] = {(TSStateId)(-1)}, }; enum { @@ -20476,7 +22927,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_ambiguous_expression_token1] = ACTIONS(1), [aux_sym_current_changed_expression_token1] = ACTIONS(1), [aux_sym_locked_expression_token1] = ACTIONS(1), - [aux_sym_input_expression_token1] = ACTIONS(1), [aux_sym_input_expression_token2] = ACTIONS(1), [anon_sym_PLUS] = ACTIONS(1), [anon_sym_DASH] = ACTIONS(1), @@ -20514,10 +22964,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_primitive_type_token15] = ACTIONS(1), [aux_sym_primitive_type_token16] = ACTIONS(1), [aux_sym_primitive_type_token17] = ACTIONS(1), - [aux_sym_variable_tuning_token1] = ACTIONS(1), + [aux_sym_primitive_type_token18] = ACTIONS(1), [aux_sym_variable_tuning_token3] = ACTIONS(1), [aux_sym_variable_tuning_token4] = ACTIONS(1), - [aux_sym_variable_tuning_token5] = ACTIONS(1), [aux_sym_scope_tuning_token1] = ACTIONS(1), [aux_sym_scope_tuning_token2] = ACTIONS(1), [aux_sym_scope_tuning_token3] = ACTIONS(1), @@ -20542,7 +22991,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_query_definition_token3] = ACTIONS(1), [anon_sym_COMMA] = ACTIONS(1), [aux_sym_argument_mode_token1] = ACTIONS(1), - [aux_sym_argument_mode_token2] = ACTIONS(1), [aux_sym_if_statement_token1] = ACTIONS(1), [aux_sym_if_statement_token2] = ACTIONS(1), [aux_sym_else_if_statement_token1] = ACTIONS(1), @@ -20550,17 +22998,26 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym__while_condition_token1] = ACTIONS(1), [aux_sym_repeat_statement_token1] = ACTIONS(1), [aux_sym_do_while_statement_token1] = ACTIONS(1), - [aux_sym_do_statement_token1] = ACTIONS(1), [aux_sym__procedure_terminator_token1] = ACTIONS(1), [aux_sym_procedure_parameter_definition_token1] = ACTIONS(1), [aux_sym_procedure_parameter_definition_token2] = ACTIONS(1), [aux_sym__function_terminator_token1] = ACTIONS(1), + [aux_sym_function_parameter_token1] = ACTIONS(1), + [aux_sym_function_parameter_token2] = ACTIONS(1), [aux_sym_function_statement_token1] = ACTIONS(1), + [aux_sym_property_tuning_token1] = ACTIONS(1), + [aux_sym_property_tuning_token2] = ACTIONS(1), + [aux_sym_setter_token1] = ACTIONS(1), + [aux_sym_property_definition_token1] = ACTIONS(1), + [aux_sym_property_definition_token2] = ACTIONS(1), + [aux_sym_event_definition_token1] = ACTIONS(1), + [aux_sym_event_definition_token2] = ACTIONS(1), + [aux_sym_method_definition_token1] = ACTIONS(1), + [aux_sym_data_relation_token1] = ACTIONS(1), + [aux_sym_data_relation_token2] = ACTIONS(1), [aux_sym_class_statement_token1] = ACTIONS(1), - [aux_sym_class_statement_token2] = ACTIONS(1), [aux_sym_implements_token1] = ACTIONS(1), [aux_sym_use_widget_pool_token1] = ACTIONS(1), - [aux_sym_abstract_token1] = ACTIONS(1), [aux_sym_final_token1] = ACTIONS(1), [anon_sym_NO_DASHERROR] = ACTIONS(1), [aux_sym_object_access_token1] = ACTIONS(1), @@ -20568,6 +23025,7 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_input_close_statement_token1] = ACTIONS(1), [aux_sym_input_close_statement_token2] = ACTIONS(1), [aux_sym_input_stream_statement_token1] = ACTIONS(1), + [aux_sym_output_stream_statement_token1] = ACTIONS(1), [aux_sym_on_error_phrase_token1] = ACTIONS(1), [aux_sym_on_error_phrase_token2] = ACTIONS(1), [aux_sym_on_error_phrase_token3] = ACTIONS(1), @@ -20575,6 +23033,9 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_on_error_phrase_token8] = ACTIONS(1), [aux_sym_on_stop_phrase_token1] = ACTIONS(1), [aux_sym_on_quit_phrase_token1] = ACTIONS(1), + [aux_sym_stop_after_phrase_token1] = ACTIONS(1), + [aux_sym_do_tuning_token1] = ACTIONS(1), + [anon_sym_BY] = ACTIONS(1), [aux_sym__case_terminator_token1] = ACTIONS(1), [aux_sym_case_when_branch_token1] = ACTIONS(1), [aux_sym_case_otherwise_branch_token1] = ACTIONS(1), @@ -20601,7 +23062,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym_of_token1] = ACTIONS(1), [aux_sym__using_first_token1] = ACTIONS(1), [aux_sym__using_and_token1] = ACTIONS(1), - [aux_sym_transaction_statement_token1] = ACTIONS(1), [aux_sym_assign_statement_token1] = ACTIONS(1), [aux_sym_catch_statement_token1] = ACTIONS(1), [aux_sym_finally_statement_token1] = ACTIONS(1), @@ -20622,7 +23082,6 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(1), [aux_sym_temp_table_tuning_token1] = ACTIONS(1), [anon_sym_LIKE] = ACTIONS(1), - [aux_sym_field_option_token1] = ACTIONS(1), [aux_sym_field_definition_token1] = ACTIONS(1), [aux_sym_index_tuning_token1] = ACTIONS(1), [aux_sym_index_tuning_token2] = ACTIONS(1), @@ -20633,49 +23092,48 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym__namedot] = ACTIONS(1), }, [1] = { - [sym_source_code] = STATE(3303), + [sym_source_code] = STATE(3777), [sym_comment] = STATE(1), [sym_include] = STATE(1), - [sym_assignment] = STATE(3302), - [sym_variable_definition] = STATE(1044), - [sym_variable_assignment] = STATE(1044), - [sym_buffer_definition] = STATE(1044), - [sym_query_definition] = STATE(1044), - [sym_function_call_statement] = STATE(1044), - [sym_function_call] = STATE(3301), - [sym_if_statement] = STATE(1044), - [sym_label] = STATE(1049), - [sym__loop_statement] = STATE(1044), - [sym_repeat_statement] = STATE(1054), - [sym_do_while_statement] = STATE(1054), - [sym_do_statement] = STATE(1054), - [sym_procedure_statement] = STATE(1044), - [sym_procedure_parameter_definition] = STATE(1044), - [sym_function_statement] = STATE(1044), - [sym_return_statement] = STATE(1044), - [sym_class_statement] = STATE(1044), - [sym_stream_definition] = STATE(1044), - [sym_input_close_statement] = STATE(1044), - [sym_output_close_statement] = STATE(1044), - [sym__stream_statement] = STATE(1044), - [sym_input_stream_statement] = STATE(1055), - [sym_output_stream_statement] = STATE(1055), - [sym_do_block] = STATE(1044), - [sym_case_statement] = STATE(1044), - [sym_for_statement] = STATE(1044), - [sym_find_statement] = STATE(1044), - [sym_transaction_statement] = STATE(1044), - [sym_abl_statement] = STATE(1044), - [sym_assign_statement] = STATE(1044), - [sym_catch_statement] = STATE(1044), - [sym_finally_statement] = STATE(1044), - [sym_accumulate_statement] = STATE(1044), - [sym_undo_statement] = STATE(1044), - [sym_error_scope_statement] = STATE(1044), - [sym_temp_table_definition] = STATE(1044), - [sym_on_statement] = STATE(1044), - [sym__statement] = STATE(1059), - [aux_sym_source_code_repeat1] = STATE(274), + [sym_assignment] = STATE(3776), + [sym_variable_definition] = STATE(1412), + [sym_variable_assignment] = STATE(1412), + [sym_buffer_definition] = STATE(1412), + [sym_query_definition] = STATE(1412), + [sym_function_call_statement] = STATE(1412), + [sym_function_call] = STATE(3774), + [sym_if_statement] = STATE(1412), + [sym_label] = STATE(1416), + [sym__loop_statement] = STATE(1412), + [sym_repeat_statement] = STATE(1425), + [sym_do_while_statement] = STATE(1425), + [sym_procedure_statement] = STATE(1412), + [sym_procedure_parameter_definition] = STATE(1412), + [sym_function_statement] = STATE(1412), + [sym_return_statement] = STATE(1412), + [sym_interface_statement] = STATE(1412), + [sym_class_statement] = STATE(1412), + [sym_stream_definition] = STATE(1412), + [sym_input_close_statement] = STATE(1412), + [sym_output_close_statement] = STATE(1412), + [sym__stream_statement] = STATE(1412), + [sym_input_stream_statement] = STATE(1428), + [sym_output_stream_statement] = STATE(1428), + [sym_do_block] = STATE(1412), + [sym_case_statement] = STATE(1412), + [sym_for_statement] = STATE(1412), + [sym_find_statement] = STATE(1412), + [sym_abl_statement] = STATE(1412), + [sym_assign_statement] = STATE(1412), + [sym_catch_statement] = STATE(1412), + [sym_finally_statement] = STATE(1412), + [sym_accumulate_statement] = STATE(1412), + [sym_undo_statement] = STATE(1412), + [sym_error_scope_statement] = STATE(1412), + [sym_temp_table_definition] = STATE(1412), + [sym_on_statement] = STATE(1412), + [sym__statement] = STATE(1466), + [aux_sym_source_code_repeat1] = STATE(281), [ts_builtin_sym_end] = ACTIONS(9), [sym_identifier] = ACTIONS(11), [anon_sym_SLASH_SLASH] = ACTIONS(3), @@ -20692,20489 +23150,21740 @@ static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [aux_sym__procedure_terminator_token1] = ACTIONS(29), [aux_sym_procedure_parameter_definition_token1] = ACTIONS(31), [aux_sym__function_terminator_token1] = ACTIONS(33), - [aux_sym_class_statement_token1] = ACTIONS(35), - [aux_sym_on_error_phrase_token1] = ACTIONS(37), - [aux_sym_on_error_phrase_token3] = ACTIONS(39), - [aux_sym__case_terminator_token1] = ACTIONS(41), - [aux_sym_find_statement_token1] = ACTIONS(43), - [aux_sym_assign_statement_token1] = ACTIONS(45), - [aux_sym_catch_statement_token1] = ACTIONS(47), - [aux_sym_finally_statement_token1] = ACTIONS(49), - [aux_sym_accumulate_statement_token1] = ACTIONS(51), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(53), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(53), + [aux_sym_interface_statement_token1] = ACTIONS(35), + [aux_sym_class_statement_token1] = ACTIONS(37), + [aux_sym_on_error_phrase_token1] = ACTIONS(39), + [aux_sym_on_error_phrase_token3] = ACTIONS(41), + [aux_sym__case_terminator_token1] = ACTIONS(43), + [aux_sym_find_statement_token1] = ACTIONS(45), + [aux_sym_assign_statement_token1] = ACTIONS(47), + [aux_sym_catch_statement_token1] = ACTIONS(49), + [aux_sym_finally_statement_token1] = ACTIONS(51), + [aux_sym_accumulate_statement_token1] = ACTIONS(53), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(55), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(55), }, [2] = { - [sym_body] = STATE(2309), [sym_comment] = STATE(2), - [sym__block_terminator] = STATE(1041), [sym_include] = STATE(2), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym__procedure_terminator] = STATE(1041), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), - [anon_sym_SLASH_SLASH] = ACTIONS(3), - [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(57), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym_qualified_name_repeat1] = STATE(3), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(61), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(65), + [anon_sym_LPAREN] = ACTIONS(65), + [anon_sym_RPAREN] = ACTIONS(65), + [aux_sym__logical_operator_token1] = ACTIONS(65), + [aux_sym__logical_operator_token2] = ACTIONS(65), + [aux_sym__logical_operator_token3] = ACTIONS(65), + [aux_sym__logical_operator_token4] = ACTIONS(65), + [aux_sym__logical_operator_token5] = ACTIONS(65), + [aux_sym__logical_operator_token6] = ACTIONS(65), + [anon_sym_PLUS] = ACTIONS(65), + [anon_sym_DASH] = ACTIONS(65), + [anon_sym_STAR] = ACTIONS(65), + [anon_sym_LT] = ACTIONS(61), + [anon_sym_LT_EQ] = ACTIONS(65), + [anon_sym_LT_GT] = ACTIONS(65), + [anon_sym_EQ] = ACTIONS(65), + [anon_sym_GT] = ACTIONS(61), + [anon_sym_GT_EQ] = ACTIONS(65), + [aux_sym__comparison_operator_token1] = ACTIONS(65), + [aux_sym__comparison_operator_token2] = ACTIONS(65), + [aux_sym__comparison_operator_token3] = ACTIONS(65), + [aux_sym__comparison_operator_token4] = ACTIONS(65), + [aux_sym__comparison_operator_token5] = ACTIONS(65), + [aux_sym__comparison_operator_token6] = ACTIONS(65), + [aux_sym__comparison_operator_token7] = ACTIONS(65), + [aux_sym__comparison_operator_token8] = ACTIONS(65), + [aux_sym__comparison_operator_token9] = ACTIONS(65), + [aux_sym_variable_tuning_token1] = ACTIONS(65), + [aux_sym_variable_tuning_token2] = ACTIONS(65), + [aux_sym_variable_tuning_token3] = ACTIONS(65), + [aux_sym_variable_tuning_token4] = ACTIONS(65), + [aux_sym_variable_tuning_token5] = ACTIONS(65), + [aux_sym_variable_tuning_token6] = ACTIONS(65), + [aux_sym_serialization_tuning_token1] = ACTIONS(65), + [aux_sym_variable_definition_token6] = ACTIONS(65), + [anon_sym_COMMA] = ACTIONS(65), + [aux_sym_if_statement_token2] = ACTIONS(65), + [aux_sym_else_if_statement_token1] = ACTIONS(65), + [anon_sym_COLON] = ACTIONS(65), + [aux_sym_property_tuning_token1] = ACTIONS(65), + [aux_sym_property_definition_token2] = ACTIONS(65), + [aux_sym_data_relation_token1] = ACTIONS(65), + [aux_sym_data_relation_token2] = ACTIONS(65), + [aux_sym_inherits_token1] = ACTIONS(65), + [aux_sym_implements_token1] = ACTIONS(65), + [aux_sym_use_widget_pool_token1] = ACTIONS(65), + [aux_sym_final_token1] = ACTIONS(65), + [aux_sym_output_stream_statement_token1] = ACTIONS(65), + [aux_sym_on_error_phrase_token1] = ACTIONS(65), + [aux_sym_where_clause_token1] = ACTIONS(65), + [aux_sym_query_tuning_token1] = ACTIONS(65), + [aux_sym_query_tuning_token2] = ACTIONS(65), + [aux_sym_query_tuning_token3] = ACTIONS(65), + [aux_sym_query_tuning_token4] = ACTIONS(65), + [aux_sym_query_tuning_token5] = ACTIONS(65), + [aux_sym_query_tuning_token6] = ACTIONS(65), + [aux_sym_sort_clause_token1] = ACTIONS(65), + [aux_sym_sort_clause_token2] = ACTIONS(65), + [aux_sym_of_token1] = ACTIONS(65), + [aux_sym__using_first_token1] = ACTIONS(65), + [aux_sym_temp_table_tuning_token1] = ACTIONS(65), + [anon_sym_LIKE] = ACTIONS(61), + [aux_sym_field_definition_token1] = ACTIONS(65), + [aux_sym_index_definition_token1] = ACTIONS(65), + [aux_sym_on_statement_token1] = ACTIONS(65), + [sym__namedot] = ACTIONS(67), }, [3] = { [sym_comment] = STATE(3), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(3), - [sym__function_call_arguments] = STATE(3256), - [sym_argument_mode] = STATE(3255), - [sym__function_argument_with_mode] = STATE(2572), - [sym_function_call_argument] = STATE(2206), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_can_find_expression] = STATE(310), - [sym_accumulate_aggregate] = STATE(2207), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(693), - [sym_identifier] = ACTIONS(101), - [anon_sym_SLASH_SLASH] = ACTIONS(3), - [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(117), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(121), - [aux_sym_ambiguous_expression_token1] = ACTIONS(123), - [aux_sym_current_changed_expression_token1] = ACTIONS(125), - [aux_sym_locked_expression_token1] = ACTIONS(127), - [aux_sym_input_expression_token1] = ACTIONS(129), - [aux_sym_scope_tuning_token1] = ACTIONS(131), - [aux_sym_argument_mode_token1] = ACTIONS(133), - [aux_sym_argument_mode_token2] = ACTIONS(133), - [aux_sym_if_statement_token1] = ACTIONS(135), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_accumulate_aggregate_token1] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token2] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token3] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token4] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token5] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token6] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token7] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token8] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token9] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token10] = ACTIONS(139), - [aux_sym_accumulate_expression_token1] = ACTIONS(141), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [aux_sym_qualified_name_repeat1] = STATE(3), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(69), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(71), + [anon_sym_LPAREN] = ACTIONS(71), + [anon_sym_RPAREN] = ACTIONS(71), + [aux_sym__logical_operator_token1] = ACTIONS(71), + [aux_sym__logical_operator_token2] = ACTIONS(71), + [aux_sym__logical_operator_token3] = ACTIONS(71), + [aux_sym__logical_operator_token4] = ACTIONS(71), + [aux_sym__logical_operator_token5] = ACTIONS(71), + [aux_sym__logical_operator_token6] = ACTIONS(71), + [anon_sym_PLUS] = ACTIONS(71), + [anon_sym_DASH] = ACTIONS(71), + [anon_sym_STAR] = ACTIONS(71), + [anon_sym_LT] = ACTIONS(69), + [anon_sym_LT_EQ] = ACTIONS(71), + [anon_sym_LT_GT] = ACTIONS(71), + [anon_sym_EQ] = ACTIONS(71), + [anon_sym_GT] = ACTIONS(69), + [anon_sym_GT_EQ] = ACTIONS(71), + [aux_sym__comparison_operator_token1] = ACTIONS(71), + [aux_sym__comparison_operator_token2] = ACTIONS(71), + [aux_sym__comparison_operator_token3] = ACTIONS(71), + [aux_sym__comparison_operator_token4] = ACTIONS(71), + [aux_sym__comparison_operator_token5] = ACTIONS(71), + [aux_sym__comparison_operator_token6] = ACTIONS(71), + [aux_sym__comparison_operator_token7] = ACTIONS(71), + [aux_sym__comparison_operator_token8] = ACTIONS(71), + [aux_sym__comparison_operator_token9] = ACTIONS(71), + [aux_sym_variable_tuning_token1] = ACTIONS(71), + [aux_sym_variable_tuning_token2] = ACTIONS(71), + [aux_sym_variable_tuning_token3] = ACTIONS(71), + [aux_sym_variable_tuning_token4] = ACTIONS(71), + [aux_sym_variable_tuning_token5] = ACTIONS(71), + [aux_sym_variable_tuning_token6] = ACTIONS(71), + [aux_sym_serialization_tuning_token1] = ACTIONS(71), + [aux_sym_variable_definition_token6] = ACTIONS(71), + [anon_sym_COMMA] = ACTIONS(71), + [aux_sym_if_statement_token2] = ACTIONS(71), + [aux_sym_else_if_statement_token1] = ACTIONS(71), + [anon_sym_COLON] = ACTIONS(71), + [aux_sym_property_tuning_token1] = ACTIONS(71), + [aux_sym_property_definition_token2] = ACTIONS(71), + [aux_sym_data_relation_token1] = ACTIONS(71), + [aux_sym_data_relation_token2] = ACTIONS(71), + [aux_sym_inherits_token1] = ACTIONS(71), + [aux_sym_implements_token1] = ACTIONS(71), + [aux_sym_use_widget_pool_token1] = ACTIONS(71), + [aux_sym_final_token1] = ACTIONS(71), + [aux_sym_output_stream_statement_token1] = ACTIONS(71), + [aux_sym_on_error_phrase_token1] = ACTIONS(71), + [aux_sym_where_clause_token1] = ACTIONS(71), + [aux_sym_query_tuning_token1] = ACTIONS(71), + [aux_sym_query_tuning_token2] = ACTIONS(71), + [aux_sym_query_tuning_token3] = ACTIONS(71), + [aux_sym_query_tuning_token4] = ACTIONS(71), + [aux_sym_query_tuning_token5] = ACTIONS(71), + [aux_sym_query_tuning_token6] = ACTIONS(71), + [aux_sym_sort_clause_token1] = ACTIONS(71), + [aux_sym_sort_clause_token2] = ACTIONS(71), + [aux_sym_of_token1] = ACTIONS(71), + [aux_sym__using_first_token1] = ACTIONS(71), + [aux_sym_temp_table_tuning_token1] = ACTIONS(71), + [anon_sym_LIKE] = ACTIONS(69), + [aux_sym_field_definition_token1] = ACTIONS(71), + [aux_sym_index_definition_token1] = ACTIONS(71), + [aux_sym_on_statement_token1] = ACTIONS(71), + [sym__namedot] = ACTIONS(73), }, [4] = { - [sym_body] = STATE(2331), + [sym_body] = STATE(2503), [sym_comment] = STATE(4), - [sym__block_terminator] = STATE(1182), + [sym__block_terminator] = STATE(1173), [sym_include] = STATE(4), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1181), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1168), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(145), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(78), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [5] = { - [sym_body] = STATE(2495), + [sym_body] = STATE(2767), [sym_comment] = STATE(5), - [sym__block_terminator] = STATE(1182), + [sym__block_terminator] = STATE(1301), [sym_include] = STATE(5), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1039), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1298), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(145), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(124), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [6] = { - [sym_body] = STATE(2450), + [sym_body] = STATE(2683), [sym_comment] = STATE(6), - [sym__block_terminator] = STATE(1182), + [sym__block_terminator] = STATE(1301), [sym_include] = STATE(6), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1074), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1130), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(145), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(124), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [7] = { - [sym_body] = STATE(2352), + [sym_body] = STATE(2684), [sym_comment] = STATE(7), - [sym__block_terminator] = STATE(1170), + [sym__block_terminator] = STATE(1301), [sym_include] = STATE(7), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym__procedure_terminator] = STATE(1170), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1198), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(57), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(124), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [8] = { [sym_comment] = STATE(8), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(8), - [sym__function_call_arguments] = STATE(3256), - [sym_argument_mode] = STATE(3255), - [sym__function_argument_with_mode] = STATE(2572), - [sym_function_call_argument] = STATE(2206), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_can_find_expression] = STATE(310), - [sym_accumulate_aggregate] = STATE(2469), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(693), - [sym_identifier] = ACTIONS(101), + [sym__function_call_arguments] = STATE(3659), + [sym_argument_mode] = STATE(3656), + [sym__function_argument_with_mode] = STATE(3075), + [sym_function_call_argument] = STATE(2866), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_can_find_expression] = STATE(308), + [sym_accumulate_aggregate] = STATE(2702), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(746), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(117), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(121), - [aux_sym_ambiguous_expression_token1] = ACTIONS(123), - [aux_sym_current_changed_expression_token1] = ACTIONS(125), - [aux_sym_locked_expression_token1] = ACTIONS(127), - [aux_sym_input_expression_token1] = ACTIONS(129), - [aux_sym_scope_tuning_token1] = ACTIONS(131), - [aux_sym_argument_mode_token1] = ACTIONS(133), - [aux_sym_argument_mode_token2] = ACTIONS(133), - [aux_sym_if_statement_token1] = ACTIONS(135), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_accumulate_aggregate_token1] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token2] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token3] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token4] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token5] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token6] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token7] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token8] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token9] = ACTIONS(139), - [aux_sym_accumulate_aggregate_token10] = ACTIONS(139), - [aux_sym_accumulate_expression_token1] = ACTIONS(141), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(142), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(146), + [aux_sym_ambiguous_expression_token1] = ACTIONS(148), + [aux_sym_current_changed_expression_token1] = ACTIONS(150), + [aux_sym_locked_expression_token1] = ACTIONS(152), + [aux_sym_input_expression_token1] = ACTIONS(154), + [aux_sym_scope_tuning_token1] = ACTIONS(156), + [aux_sym_argument_mode_token1] = ACTIONS(158), + [aux_sym_argument_mode_token2] = ACTIONS(158), + [aux_sym_if_statement_token1] = ACTIONS(160), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_accumulate_aggregate_token1] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token2] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token3] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token4] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token5] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token6] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token7] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token8] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token9] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token10] = ACTIONS(164), + [aux_sym_accumulate_expression_token1] = ACTIONS(166), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), }, [9] = { - [sym_body] = STATE(2184), + [sym_body] = STATE(2525), [sym_comment] = STATE(9), - [sym__block_terminator] = STATE(1375), + [sym__block_terminator] = STATE(1158), [sym_include] = STATE(9), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1377), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym__procedure_terminator] = STATE(1158), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(147), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(170), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [10] = { - [sym_body] = STATE(2215), + [sym_body] = STATE(2632), [sym_comment] = STATE(10), - [sym__block_terminator] = STATE(1375), + [sym__block_terminator] = STATE(1173), [sym_include] = STATE(10), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1277), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1126), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(147), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(78), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [11] = { - [sym_body] = STATE(2287), + [sym_body] = STATE(2501), [sym_comment] = STATE(11), - [sym__block_terminator] = STATE(1226), + [sym__block_terminator] = STATE(1173), [sym_include] = STATE(11), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym__procedure_terminator] = STATE(1226), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym__function_terminator] = STATE(1177), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(149), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(78), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [12] = { - [sym_body] = STATE(2217), [sym_comment] = STATE(12), - [sym__block_terminator] = STATE(1262), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(12), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym__procedure_terminator] = STATE(1262), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym__function_call_arguments] = STATE(3659), + [sym_argument_mode] = STATE(3656), + [sym__function_argument_with_mode] = STATE(3075), + [sym_function_call_argument] = STATE(2866), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_can_find_expression] = STATE(308), + [sym_accumulate_aggregate] = STATE(2856), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(746), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(149), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(142), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(146), + [aux_sym_ambiguous_expression_token1] = ACTIONS(148), + [aux_sym_current_changed_expression_token1] = ACTIONS(150), + [aux_sym_locked_expression_token1] = ACTIONS(152), + [aux_sym_input_expression_token1] = ACTIONS(154), + [aux_sym_scope_tuning_token1] = ACTIONS(156), + [aux_sym_argument_mode_token1] = ACTIONS(158), + [aux_sym_argument_mode_token2] = ACTIONS(158), + [aux_sym_if_statement_token1] = ACTIONS(160), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_accumulate_aggregate_token1] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token2] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token3] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token4] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token5] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token6] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token7] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token8] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token9] = ACTIONS(164), + [aux_sym_accumulate_aggregate_token10] = ACTIONS(164), + [aux_sym_accumulate_expression_token1] = ACTIONS(166), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), }, [13] = { - [sym_body] = STATE(2222), [sym_comment] = STATE(13), - [sym__block_terminator] = STATE(1375), [sym_include] = STATE(13), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym__function_terminator] = STATE(1376), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), - [anon_sym_SLASH_SLASH] = ACTIONS(3), - [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(147), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(69), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(71), + [anon_sym_LPAREN] = ACTIONS(71), + [anon_sym_RPAREN] = ACTIONS(71), + [aux_sym__logical_operator_token1] = ACTIONS(71), + [aux_sym__logical_operator_token2] = ACTIONS(71), + [aux_sym__logical_operator_token3] = ACTIONS(71), + [aux_sym__logical_operator_token4] = ACTIONS(71), + [aux_sym__logical_operator_token5] = ACTIONS(71), + [aux_sym__logical_operator_token6] = ACTIONS(71), + [anon_sym_PLUS] = ACTIONS(71), + [anon_sym_DASH] = ACTIONS(71), + [anon_sym_STAR] = ACTIONS(71), + [anon_sym_LT] = ACTIONS(69), + [anon_sym_LT_EQ] = ACTIONS(71), + [anon_sym_LT_GT] = ACTIONS(71), + [anon_sym_EQ] = ACTIONS(71), + [anon_sym_GT] = ACTIONS(69), + [anon_sym_GT_EQ] = ACTIONS(71), + [aux_sym__comparison_operator_token1] = ACTIONS(71), + [aux_sym__comparison_operator_token2] = ACTIONS(71), + [aux_sym__comparison_operator_token3] = ACTIONS(71), + [aux_sym__comparison_operator_token4] = ACTIONS(71), + [aux_sym__comparison_operator_token5] = ACTIONS(71), + [aux_sym__comparison_operator_token6] = ACTIONS(71), + [aux_sym__comparison_operator_token7] = ACTIONS(71), + [aux_sym__comparison_operator_token8] = ACTIONS(71), + [aux_sym__comparison_operator_token9] = ACTIONS(71), + [aux_sym_variable_tuning_token1] = ACTIONS(71), + [aux_sym_variable_tuning_token2] = ACTIONS(71), + [aux_sym_variable_tuning_token3] = ACTIONS(71), + [aux_sym_variable_tuning_token4] = ACTIONS(71), + [aux_sym_variable_tuning_token5] = ACTIONS(71), + [aux_sym_variable_tuning_token6] = ACTIONS(71), + [aux_sym_serialization_tuning_token1] = ACTIONS(71), + [aux_sym_variable_definition_token6] = ACTIONS(71), + [anon_sym_COMMA] = ACTIONS(71), + [aux_sym_if_statement_token2] = ACTIONS(71), + [aux_sym_else_if_statement_token1] = ACTIONS(71), + [anon_sym_COLON] = ACTIONS(71), + [aux_sym_property_tuning_token1] = ACTIONS(71), + [aux_sym_property_definition_token2] = ACTIONS(71), + [aux_sym_data_relation_token1] = ACTIONS(71), + [aux_sym_data_relation_token2] = ACTIONS(71), + [aux_sym_inherits_token1] = ACTIONS(71), + [aux_sym_implements_token1] = ACTIONS(71), + [aux_sym_use_widget_pool_token1] = ACTIONS(71), + [aux_sym_final_token1] = ACTIONS(71), + [aux_sym_output_stream_statement_token1] = ACTIONS(71), + [aux_sym_on_error_phrase_token1] = ACTIONS(71), + [aux_sym_where_clause_token1] = ACTIONS(71), + [aux_sym_query_tuning_token1] = ACTIONS(71), + [aux_sym_query_tuning_token2] = ACTIONS(71), + [aux_sym_query_tuning_token3] = ACTIONS(71), + [aux_sym_query_tuning_token4] = ACTIONS(71), + [aux_sym_query_tuning_token5] = ACTIONS(71), + [aux_sym_query_tuning_token6] = ACTIONS(71), + [aux_sym_sort_clause_token1] = ACTIONS(71), + [aux_sym_sort_clause_token2] = ACTIONS(71), + [aux_sym_of_token1] = ACTIONS(71), + [aux_sym__using_first_token1] = ACTIONS(71), + [aux_sym_temp_table_tuning_token1] = ACTIONS(71), + [anon_sym_LIKE] = ACTIONS(69), + [aux_sym_field_definition_token1] = ACTIONS(71), + [aux_sym_index_definition_token1] = ACTIONS(71), + [aux_sym_on_statement_token1] = ACTIONS(71), + [sym__namedot] = ACTIONS(71), }, [14] = { - [sym_body] = STATE(2779), + [sym_body] = STATE(2531), [sym_comment] = STATE(14), - [sym__block_terminator] = STATE(868), + [sym__block_terminator] = STATE(1386), [sym_include] = STATE(14), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym__procedure_terminator] = STATE(1386), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(172), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [15] = { - [sym_body] = STATE(2685), + [sym_body] = STATE(2602), [sym_comment] = STATE(15), - [sym__block_terminator] = STATE(987), + [sym__block_terminator] = STATE(1102), [sym_include] = STATE(15), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym__procedure_terminator] = STATE(1102), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(172), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [16] = { - [sym_body] = STATE(2607), + [sym_body] = STATE(2758), [sym_comment] = STATE(16), - [sym__block_terminator] = STATE(2361), + [sym__block_terminator] = STATE(1212), [sym_include] = STATE(16), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym__procedure_terminator] = STATE(1212), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(170), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [17] = { - [sym_body] = STATE(2608), + [sym_body] = STATE(2932), [sym_comment] = STATE(17), - [sym__block_terminator] = STATE(2366), + [sym__block_terminator] = STATE(2823), [sym_include] = STATE(17), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [18] = { + [sym_body] = STATE(3089), [sym_comment] = STATE(18), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(954), [sym_include] = STATE(18), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(556), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1561), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(157), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [19] = { - [sym_body] = STATE(2612), + [sym_body] = STATE(3054), [sym_comment] = STATE(19), - [sym__block_terminator] = STATE(2376), + [sym__block_terminator] = STATE(1240), [sym_include] = STATE(19), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [20] = { - [sym_body] = STATE(2613), + [sym_body] = STATE(3044), [sym_comment] = STATE(20), - [sym__block_terminator] = STATE(2403), + [sym__block_terminator] = STATE(1172), [sym_include] = STATE(20), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [21] = { - [sym_body] = STATE(2615), + [sym_body] = STATE(3309), [sym_comment] = STATE(21), - [sym__block_terminator] = STATE(2378), + [sym__block_terminator] = STATE(1190), [sym_include] = STATE(21), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [22] = { - [sym_body] = STATE(2618), + [sym_body] = STATE(3192), [sym_comment] = STATE(22), - [sym__block_terminator] = STATE(2389), + [sym__block_terminator] = STATE(1243), [sym_include] = STATE(22), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [23] = { - [sym_body] = STATE(2619), + [sym_body] = STATE(3023), [sym_comment] = STATE(23), - [sym__block_terminator] = STATE(2397), + [sym__block_terminator] = STATE(1257), [sym_include] = STATE(23), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [24] = { - [sym_body] = STATE(2620), + [sym_body] = STATE(3006), [sym_comment] = STATE(24), - [sym__block_terminator] = STATE(2401), + [sym__block_terminator] = STATE(1293), [sym_include] = STATE(24), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [25] = { - [sym_body] = STATE(2621), + [sym_body] = STATE(3063), [sym_comment] = STATE(25), - [sym__block_terminator] = STATE(2410), + [sym__block_terminator] = STATE(1303), [sym_include] = STATE(25), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [26] = { - [sym_body] = STATE(2622), + [sym_body] = STATE(3193), [sym_comment] = STATE(26), - [sym__block_terminator] = STATE(2417), + [sym__block_terminator] = STATE(1328), [sym_include] = STATE(26), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [27] = { - [sym_body] = STATE(2623), + [sym_body] = STATE(3268), [sym_comment] = STATE(27), - [sym__block_terminator] = STATE(2431), + [sym__block_terminator] = STATE(1335), [sym_include] = STATE(27), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [28] = { - [sym_body] = STATE(2624), + [sym_body] = STATE(3323), [sym_comment] = STATE(28), - [sym__block_terminator] = STATE(2432), + [sym__block_terminator] = STATE(1352), [sym_include] = STATE(28), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [29] = { - [sym_body] = STATE(2625), + [sym_body] = STATE(3333), [sym_comment] = STATE(29), - [sym__block_terminator] = STATE(2433), + [sym__block_terminator] = STATE(1357), [sym_include] = STATE(29), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [30] = { - [sym_body] = STATE(2808), + [sym_body] = STATE(3359), [sym_comment] = STATE(30), - [sym__block_terminator] = STATE(1086), + [sym__block_terminator] = STATE(1370), [sym_include] = STATE(30), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [31] = { - [sym_body] = STATE(2819), + [sym_body] = STATE(3356), [sym_comment] = STATE(31), - [sym__block_terminator] = STATE(1082), + [sym__block_terminator] = STATE(1381), [sym_include] = STATE(31), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [32] = { - [sym_body] = STATE(2626), + [sym_body] = STATE(3357), [sym_comment] = STATE(32), - [sym__block_terminator] = STATE(2439), + [sym__block_terminator] = STATE(1325), [sym_include] = STATE(32), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [33] = { - [sym_body] = STATE(2627), + [sym_body] = STATE(3257), [sym_comment] = STATE(33), - [sym__block_terminator] = STATE(2445), + [sym__block_terminator] = STATE(1125), [sym_include] = STATE(33), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [34] = { - [sym_body] = STATE(2821), + [sym_body] = STATE(3250), [sym_comment] = STATE(34), - [sym__block_terminator] = STATE(1072), + [sym__block_terminator] = STATE(1371), [sym_include] = STATE(34), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [35] = { - [sym_body] = STATE(2628), + [sym_body] = STATE(3366), [sym_comment] = STATE(35), - [sym__block_terminator] = STATE(2449), + [sym__block_terminator] = STATE(2497), [sym_include] = STATE(35), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [36] = { - [sym_body] = STATE(2632), + [sym_body] = STATE(3231), [sym_comment] = STATE(36), - [sym__block_terminator] = STATE(2460), + [sym__block_terminator] = STATE(1103), [sym_include] = STATE(36), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [37] = { - [sym_body] = STATE(2635), + [sym_body] = STATE(3157), [sym_comment] = STATE(37), - [sym__block_terminator] = STATE(2461), + [sym__block_terminator] = STATE(1396), [sym_include] = STATE(37), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [38] = { - [sym_body] = STATE(2637), + [sym_body] = STATE(3353), [sym_comment] = STATE(38), - [sym__block_terminator] = STATE(2464), + [sym__block_terminator] = STATE(1025), [sym_include] = STATE(38), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [39] = { - [sym_body] = STATE(2802), + [sym_body] = STATE(3099), [sym_comment] = STATE(39), - [sym__block_terminator] = STATE(1103), + [sym__block_terminator] = STATE(1106), [sym_include] = STATE(39), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [40] = { + [sym_body] = STATE(3120), [sym_comment] = STATE(40), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1174), [sym_include] = STATE(40), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(557), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1553), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(189), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [41] = { - [sym_body] = STATE(2638), + [sym_body] = STATE(3275), [sym_comment] = STATE(41), - [sym__block_terminator] = STATE(2470), + [sym__block_terminator] = STATE(1414), [sym_include] = STATE(41), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [42] = { - [sym_body] = STATE(2639), + [sym_body] = STATE(2978), [sym_comment] = STATE(42), - [sym__block_terminator] = STATE(2476), + [sym__block_terminator] = STATE(1324), [sym_include] = STATE(42), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [43] = { - [sym_body] = STATE(2580), + [sym_body] = STATE(2937), [sym_comment] = STATE(43), - [sym__block_terminator] = STATE(2335), + [sym__block_terminator] = STATE(1283), [sym_include] = STATE(43), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [44] = { - [sym_body] = STATE(2832), + [sym_body] = STATE(2962), [sym_comment] = STATE(44), - [sym__block_terminator] = STATE(1005), + [sym__block_terminator] = STATE(1280), [sym_include] = STATE(44), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [45] = { - [sym_body] = STATE(2841), + [sym_body] = STATE(3087), [sym_comment] = STATE(45), - [sym__block_terminator] = STATE(1024), + [sym__block_terminator] = STATE(1417), [sym_include] = STATE(45), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [46] = { + [sym_body] = STATE(3315), [sym_comment] = STATE(46), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1024), [sym_include] = STATE(46), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(562), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1559), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(191), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [47] = { - [sym_body] = STATE(2858), + [sym_body] = STATE(3314), [sym_comment] = STATE(47), - [sym__block_terminator] = STATE(1029), + [sym__block_terminator] = STATE(1341), [sym_include] = STATE(47), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [48] = { - [sym_body] = STATE(2642), + [sym_body] = STATE(3299), [sym_comment] = STATE(48), - [sym__block_terminator] = STATE(2477), + [sym__block_terminator] = STATE(1340), [sym_include] = STATE(48), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [49] = { - [sym_body] = STATE(2643), + [sym_body] = STATE(3290), [sym_comment] = STATE(49), - [sym__block_terminator] = STATE(2478), + [sym__block_terminator] = STATE(1339), [sym_include] = STATE(49), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [50] = { - [sym_body] = STATE(2644), + [sym_body] = STATE(3264), [sym_comment] = STATE(50), - [sym__block_terminator] = STATE(2479), + [sym__block_terminator] = STATE(1332), [sym_include] = STATE(50), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [51] = { - [sym_body] = STATE(2645), + [sym_body] = STATE(3258), [sym_comment] = STATE(51), - [sym__block_terminator] = STATE(2487), + [sym__block_terminator] = STATE(1331), [sym_include] = STATE(51), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [52] = { - [sym_body] = STATE(2867), + [sym_body] = STATE(3159), [sym_comment] = STATE(52), - [sym__block_terminator] = STATE(1046), + [sym__block_terminator] = STATE(1320), [sym_include] = STATE(52), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [53] = { + [sym_body] = STATE(3125), [sym_comment] = STATE(53), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1437), [sym_include] = STATE(53), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(555), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1565), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(193), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [54] = { - [sym_body] = STATE(2870), + [sym_body] = STATE(3136), [sym_comment] = STATE(54), - [sym__block_terminator] = STATE(1053), + [sym__block_terminator] = STATE(1438), [sym_include] = STATE(54), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [55] = { - [sym_body] = STATE(2648), + [sym_body] = STATE(3196), [sym_comment] = STATE(55), - [sym__block_terminator] = STATE(2498), + [sym__block_terminator] = STATE(1469), [sym_include] = STATE(55), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [56] = { - [sym_body] = STATE(2649), + [sym_body] = STATE(3234), [sym_comment] = STATE(56), - [sym__block_terminator] = STATE(2500), + [sym__block_terminator] = STATE(1468), [sym_include] = STATE(56), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [57] = { - [sym_body] = STATE(2652), + [sym_body] = STATE(2920), [sym_comment] = STATE(57), - [sym__block_terminator] = STATE(2499), + [sym__block_terminator] = STATE(1471), [sym_include] = STATE(57), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [58] = { - [sym_body] = STATE(2871), + [sym_body] = STATE(3255), [sym_comment] = STATE(58), - [sym__block_terminator] = STATE(1065), + [sym__block_terminator] = STATE(1470), [sym_include] = STATE(58), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [59] = { - [sym_body] = STATE(2657), [sym_comment] = STATE(59), - [sym__block_terminator] = STATE(2513), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(59), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(585), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1674), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(184), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [60] = { - [sym_body] = STATE(2658), [sym_comment] = STATE(60), - [sym__block_terminator] = STATE(2514), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(60), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(588), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1661), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(214), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [61] = { - [sym_body] = STATE(2872), + [sym_body] = STATE(3342), [sym_comment] = STATE(61), - [sym__block_terminator] = STATE(1066), + [sym__block_terminator] = STATE(1418), [sym_include] = STATE(61), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [62] = { - [sym_body] = STATE(2672), + [sym_body] = STATE(3372), [sym_comment] = STATE(62), - [sym__block_terminator] = STATE(997), + [sym__block_terminator] = STATE(1401), [sym_include] = STATE(62), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [63] = { - [sym_body] = STATE(2673), + [sym_body] = STATE(3363), [sym_comment] = STATE(63), - [sym__block_terminator] = STATE(996), + [sym__block_terminator] = STATE(1400), [sym_include] = STATE(63), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [64] = { - [sym_body] = STATE(2674), + [sym_body] = STATE(3358), [sym_comment] = STATE(64), - [sym__block_terminator] = STATE(995), + [sym__block_terminator] = STATE(1399), [sym_include] = STATE(64), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [65] = { - [sym_body] = STATE(2660), + [sym_body] = STATE(3374), [sym_comment] = STATE(65), - [sym__block_terminator] = STATE(994), + [sym__block_terminator] = STATE(1233), [sym_include] = STATE(65), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [66] = { - [sym_body] = STATE(2676), + [sym_body] = STATE(3350), [sym_comment] = STATE(66), - [sym__block_terminator] = STATE(993), + [sym__block_terminator] = STATE(1398), [sym_include] = STATE(66), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [67] = { - [sym_body] = STATE(2677), + [sym_body] = STATE(3348), [sym_comment] = STATE(67), - [sym__block_terminator] = STATE(992), + [sym__block_terminator] = STATE(1394), [sym_include] = STATE(67), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [68] = { - [sym_body] = STATE(2678), + [sym_body] = STATE(3279), [sym_comment] = STATE(68), - [sym__block_terminator] = STATE(991), + [sym__block_terminator] = STATE(1231), [sym_include] = STATE(68), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [69] = { - [sym_body] = STATE(2679), + [sym_body] = STATE(3254), [sym_comment] = STATE(69), - [sym__block_terminator] = STATE(990), + [sym__block_terminator] = STATE(1364), [sym_include] = STATE(69), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [70] = { - [sym_body] = STATE(2680), + [sym_body] = STATE(3238), [sym_comment] = STATE(70), - [sym__block_terminator] = STATE(989), + [sym__block_terminator] = STATE(1363), [sym_include] = STATE(70), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [71] = { - [sym_body] = STATE(2682), [sym_comment] = STATE(71), - [sym__block_terminator] = STATE(988), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(71), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(590), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1653), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(216), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [72] = { + [sym_body] = STATE(3175), [sym_comment] = STATE(72), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1336), [sym_include] = STATE(72), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(561), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1552), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(195), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [73] = { - [sym_body] = STATE(2690), + [sym_body] = STATE(3165), [sym_comment] = STATE(73), - [sym__block_terminator] = STATE(985), + [sym__block_terminator] = STATE(1319), [sym_include] = STATE(73), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [74] = { - [sym_body] = STATE(2691), + [sym_body] = STATE(3161), [sym_comment] = STATE(74), - [sym__block_terminator] = STATE(984), + [sym__block_terminator] = STATE(1317), [sym_include] = STATE(74), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [75] = { - [sym_body] = STATE(2692), + [sym_body] = STATE(3144), [sym_comment] = STATE(75), - [sym__block_terminator] = STATE(981), + [sym__block_terminator] = STATE(1314), [sym_include] = STATE(75), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [76] = { - [sym_body] = STATE(2693), + [sym_body] = STATE(3135), [sym_comment] = STATE(76), - [sym__block_terminator] = STATE(977), + [sym__block_terminator] = STATE(1313), [sym_include] = STATE(76), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [77] = { - [sym_body] = STATE(2873), + [sym_body] = STATE(3133), [sym_comment] = STATE(77), - [sym__block_terminator] = STATE(1069), + [sym__block_terminator] = STATE(1312), [sym_include] = STATE(77), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [78] = { - [sym_body] = STATE(2694), + [sym_body] = STATE(3053), [sym_comment] = STATE(78), - [sym__block_terminator] = STATE(975), + [sym__block_terminator] = STATE(1290), [sym_include] = STATE(78), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [79] = { - [sym_body] = STATE(2695), + [sym_body] = STATE(3050), [sym_comment] = STATE(79), - [sym__block_terminator] = STATE(967), + [sym__block_terminator] = STATE(1288), [sym_include] = STATE(79), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [80] = { - [sym_body] = STATE(2696), + [sym_body] = STATE(3030), [sym_comment] = STATE(80), - [sym__block_terminator] = STATE(974), + [sym__block_terminator] = STATE(1287), [sym_include] = STATE(80), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [81] = { - [sym_body] = STATE(2698), + [sym_body] = STATE(3025), [sym_comment] = STATE(81), - [sym__block_terminator] = STATE(971), + [sym__block_terminator] = STATE(1286), [sym_include] = STATE(81), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [82] = { - [sym_body] = STATE(2700), + [sym_body] = STATE(2972), [sym_comment] = STATE(82), - [sym__block_terminator] = STATE(970), + [sym__block_terminator] = STATE(1266), [sym_include] = STATE(82), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [83] = { - [sym_body] = STATE(2701), + [sym_body] = STATE(2965), [sym_comment] = STATE(83), - [sym__block_terminator] = STATE(968), + [sym__block_terminator] = STATE(1255), [sym_include] = STATE(83), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [84] = { - [sym_body] = STATE(2702), [sym_comment] = STATE(84), - [sym__block_terminator] = STATE(965), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(84), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(586), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1660), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(218), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [85] = { - [sym_body] = STATE(2703), + [sym_body] = STATE(3373), [sym_comment] = STATE(85), - [sym__block_terminator] = STATE(961), + [sym__block_terminator] = STATE(1029), [sym_include] = STATE(85), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [86] = { - [sym_body] = STATE(2704), + [sym_body] = STATE(2961), [sym_comment] = STATE(86), - [sym__block_terminator] = STATE(960), + [sym__block_terminator] = STATE(1252), [sym_include] = STATE(86), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [87] = { - [sym_body] = STATE(2705), + [sym_body] = STATE(3033), [sym_comment] = STATE(87), - [sym__block_terminator] = STATE(959), + [sym__block_terminator] = STATE(1228), [sym_include] = STATE(87), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [88] = { - [sym_body] = STATE(2706), + [sym_body] = STATE(3349), [sym_comment] = STATE(88), - [sym__block_terminator] = STATE(956), + [sym__block_terminator] = STATE(1031), [sym_include] = STATE(88), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [89] = { - [sym_body] = STATE(2707), + [sym_body] = STATE(3048), [sym_comment] = STATE(89), - [sym__block_terminator] = STATE(953), + [sym__block_terminator] = STATE(1226), [sym_include] = STATE(89), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [90] = { - [sym_body] = STATE(2606), + [sym_body] = STATE(3078), [sym_comment] = STATE(90), - [sym__block_terminator] = STATE(1102), + [sym__block_terminator] = STATE(1222), [sym_include] = STATE(90), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [91] = { - [sym_body] = STATE(2708), + [sym_body] = STATE(3104), [sym_comment] = STATE(91), - [sym__block_terminator] = STATE(952), + [sym__block_terminator] = STATE(1204), [sym_include] = STATE(91), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [92] = { - [sym_body] = STATE(2712), + [sym_body] = STATE(3111), [sym_comment] = STATE(92), - [sym__block_terminator] = STATE(951), + [sym__block_terminator] = STATE(1253), [sym_include] = STATE(92), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [93] = { - [sym_body] = STATE(2713), + [sym_body] = STATE(3220), [sym_comment] = STATE(93), - [sym__block_terminator] = STATE(947), + [sym__block_terminator] = STATE(1131), [sym_include] = STATE(93), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [94] = { - [sym_body] = STATE(2714), + [sym_body] = STATE(3240), [sym_comment] = STATE(94), - [sym__block_terminator] = STATE(946), + [sym__block_terminator] = STATE(1188), [sym_include] = STATE(94), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [95] = { - [sym_body] = STATE(2715), + [sym_body] = STATE(3147), [sym_comment] = STATE(95), - [sym__block_terminator] = STATE(944), + [sym__block_terminator] = STATE(1148), [sym_include] = STATE(95), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [96] = { - [sym_body] = STATE(2889), + [sym_body] = STATE(3321), [sym_comment] = STATE(96), - [sym__block_terminator] = STATE(1106), + [sym__block_terminator] = STATE(1143), [sym_include] = STATE(96), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [97] = { + [sym_body] = STATE(3347), [sym_comment] = STATE(97), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1033), [sym_include] = STATE(97), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(558), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1548), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(197), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [98] = { - [sym_body] = STATE(2656), + [sym_body] = STATE(3345), [sym_comment] = STATE(98), - [sym__block_terminator] = STATE(1200), + [sym__block_terminator] = STATE(1034), [sym_include] = STATE(98), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [99] = { - [sym_body] = STATE(2716), + [sym_body] = STATE(3308), [sym_comment] = STATE(99), - [sym__block_terminator] = STATE(943), + [sym__block_terminator] = STATE(1183), [sym_include] = STATE(99), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [100] = { - [sym_body] = STATE(2717), + [sym_body] = STATE(3297), [sym_comment] = STATE(100), - [sym__block_terminator] = STATE(940), + [sym__block_terminator] = STATE(1133), [sym_include] = STATE(100), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [101] = { - [sym_body] = STATE(2718), + [sym_body] = STATE(3286), [sym_comment] = STATE(101), - [sym__block_terminator] = STATE(939), + [sym__block_terminator] = STATE(1127), [sym_include] = STATE(101), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [102] = { - [sym_body] = STATE(2719), + [sym_body] = STATE(3093), [sym_comment] = STATE(102), - [sym__block_terminator] = STATE(938), + [sym__block_terminator] = STATE(1118), [sym_include] = STATE(102), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [103] = { - [sym_body] = STATE(2721), + [sym_body] = STATE(3253), [sym_comment] = STATE(103), - [sym__block_terminator] = STATE(937), + [sym__block_terminator] = STATE(1107), [sym_include] = STATE(103), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [104] = { - [sym_body] = STATE(2722), + [sym_body] = STATE(3055), [sym_comment] = STATE(104), - [sym__block_terminator] = STATE(935), + [sym__block_terminator] = STATE(1260), [sym_include] = STATE(104), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [105] = { - [sym_body] = STATE(2917), + [sym_body] = STATE(3344), [sym_comment] = STATE(105), - [sym__block_terminator] = STATE(1114), + [sym__block_terminator] = STATE(1035), [sym_include] = STATE(105), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [106] = { + [sym_body] = STATE(2944), [sym_comment] = STATE(106), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1282), [sym_include] = STATE(106), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(560), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1557), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(199), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [107] = { - [sym_body] = STATE(2581), + [sym_body] = STATE(2951), [sym_comment] = STATE(107), - [sym__block_terminator] = STATE(2340), + [sym__block_terminator] = STATE(1322), [sym_include] = STATE(107), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [108] = { - [sym_body] = STATE(2724), + [sym_body] = STATE(2952), [sym_comment] = STATE(108), - [sym__block_terminator] = STATE(934), + [sym__block_terminator] = STATE(1329), [sym_include] = STATE(108), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [109] = { - [sym_body] = STATE(2725), + [sym_body] = STATE(2954), [sym_comment] = STATE(109), - [sym__block_terminator] = STATE(932), + [sym__block_terminator] = STATE(1333), [sym_include] = STATE(109), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [110] = { - [sym_body] = STATE(2726), + [sym_body] = STATE(2955), [sym_comment] = STATE(110), - [sym__block_terminator] = STATE(933), + [sym__block_terminator] = STATE(1334), [sym_include] = STATE(110), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [111] = { - [sym_body] = STATE(2899), + [sym_body] = STATE(2957), [sym_comment] = STATE(111), - [sym__block_terminator] = STATE(1119), + [sym__block_terminator] = STATE(1358), [sym_include] = STATE(111), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [112] = { - [sym_body] = STATE(2730), + [sym_body] = STATE(2960), [sym_comment] = STATE(112), - [sym__block_terminator] = STATE(927), + [sym__block_terminator] = STATE(1359), [sym_include] = STATE(112), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [113] = { - [sym_body] = STATE(2731), + [sym_body] = STATE(2967), [sym_comment] = STATE(113), - [sym__block_terminator] = STATE(926), + [sym__block_terminator] = STATE(1361), [sym_include] = STATE(113), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(153), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [114] = { - [sym_body] = STATE(2741), [sym_comment] = STATE(114), - [sym__block_terminator] = STATE(919), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(114), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(595), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1671), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(220), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [115] = { - [sym_body] = STATE(2742), + [sym_body] = STATE(2969), [sym_comment] = STATE(115), - [sym__block_terminator] = STATE(914), + [sym__block_terminator] = STATE(1392), [sym_include] = STATE(115), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(182), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [116] = { - [sym_body] = STATE(2743), + [sym_body] = STATE(3322), [sym_comment] = STATE(116), - [sym__block_terminator] = STATE(913), + [sym__block_terminator] = STATE(1211), [sym_include] = STATE(116), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [117] = { - [sym_body] = STATE(2744), + [sym_body] = STATE(3354), [sym_comment] = STATE(117), - [sym__block_terminator] = STATE(912), + [sym__block_terminator] = STATE(1209), [sym_include] = STATE(117), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [118] = { - [sym_body] = STATE(2745), [sym_comment] = STATE(118), - [sym__block_terminator] = STATE(911), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(118), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(596), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1669), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(222), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [119] = { - [sym_body] = STATE(2746), + [sym_body] = STATE(3328), [sym_comment] = STATE(119), - [sym__block_terminator] = STATE(910), + [sym__block_terminator] = STATE(1208), [sym_include] = STATE(119), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [120] = { - [sym_body] = STATE(2747), + [sym_body] = STATE(3329), [sym_comment] = STATE(120), - [sym__block_terminator] = STATE(909), + [sym__block_terminator] = STATE(1207), [sym_include] = STATE(120), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [121] = { - [sym_body] = STATE(2748), + [sym_body] = STATE(3362), [sym_comment] = STATE(121), - [sym__block_terminator] = STATE(908), + [sym__block_terminator] = STATE(1206), [sym_include] = STATE(121), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [122] = { - [sym_body] = STATE(2900), + [sym_body] = STATE(2950), [sym_comment] = STATE(122), - [sym__block_terminator] = STATE(1120), + [sym__block_terminator] = STATE(2861), [sym_include] = STATE(122), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [123] = { - [sym_body] = STATE(2749), + [sym_body] = STATE(2949), [sym_comment] = STATE(123), - [sym__block_terminator] = STATE(907), + [sym__block_terminator] = STATE(2872), [sym_include] = STATE(123), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [124] = { - [sym_body] = STATE(2750), + [sym_body] = STATE(2948), [sym_comment] = STATE(124), - [sym__block_terminator] = STATE(906), + [sym__block_terminator] = STATE(2873), [sym_include] = STATE(124), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [125] = { - [sym_body] = STATE(2751), + [sym_body] = STATE(2946), [sym_comment] = STATE(125), - [sym__block_terminator] = STATE(905), + [sym__block_terminator] = STATE(2874), [sym_include] = STATE(125), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [126] = { - [sym_body] = STATE(2752), + [sym_body] = STATE(2945), [sym_comment] = STATE(126), - [sym__block_terminator] = STATE(903), + [sym__block_terminator] = STATE(2875), [sym_include] = STATE(126), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [127] = { - [sym_body] = STATE(2753), + [sym_body] = STATE(2943), [sym_comment] = STATE(127), - [sym__block_terminator] = STATE(902), + [sym__block_terminator] = STATE(2887), [sym_include] = STATE(127), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [128] = { - [sym_body] = STATE(2754), + [sym_body] = STATE(2942), [sym_comment] = STATE(128), - [sym__block_terminator] = STATE(899), + [sym__block_terminator] = STATE(2888), [sym_include] = STATE(128), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [129] = { - [sym_body] = STATE(2755), + [sym_body] = STATE(2941), [sym_comment] = STATE(129), - [sym__block_terminator] = STATE(896), + [sym__block_terminator] = STATE(2890), [sym_include] = STATE(129), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [130] = { - [sym_body] = STATE(2756), + [sym_body] = STATE(3341), [sym_comment] = STATE(130), - [sym__block_terminator] = STATE(890), + [sym__block_terminator] = STATE(1036), [sym_include] = STATE(130), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [131] = { - [sym_body] = STATE(2757), + [sym_body] = STATE(3069), [sym_comment] = STATE(131), - [sym__block_terminator] = STATE(882), + [sym__block_terminator] = STATE(945), [sym_include] = STATE(131), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [132] = { - [sym_body] = STATE(2903), + [sym_body] = STATE(3071), [sym_comment] = STATE(132), - [sym__block_terminator] = STATE(1144), + [sym__block_terminator] = STATE(946), [sym_include] = STATE(132), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [133] = { - [sym_body] = STATE(2758), + [sym_body] = STATE(2939), [sym_comment] = STATE(133), - [sym__block_terminator] = STATE(889), + [sym__block_terminator] = STATE(2891), [sym_include] = STATE(133), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [134] = { - [sym_body] = STATE(2759), + [sym_body] = STATE(2938), [sym_comment] = STATE(134), - [sym__block_terminator] = STATE(886), + [sym__block_terminator] = STATE(2892), [sym_include] = STATE(134), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [135] = { - [sym_body] = STATE(2760), + [sym_body] = STATE(2936), [sym_comment] = STATE(135), - [sym__block_terminator] = STATE(885), + [sym__block_terminator] = STATE(2893), [sym_include] = STATE(135), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [136] = { - [sym_body] = STATE(2761), + [sym_body] = STATE(2935), [sym_comment] = STATE(136), - [sym__block_terminator] = STATE(883), + [sym__block_terminator] = STATE(2896), [sym_include] = STATE(136), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [137] = { - [sym_body] = STATE(2762), + [sym_body] = STATE(2933), [sym_comment] = STATE(137), - [sym__block_terminator] = STATE(880), + [sym__block_terminator] = STATE(2903), [sym_include] = STATE(137), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [138] = { - [sym_body] = STATE(2763), + [sym_body] = STATE(3100), [sym_comment] = STATE(138), - [sym__block_terminator] = STATE(852), + [sym__block_terminator] = STATE(1258), [sym_include] = STATE(138), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [139] = { - [sym_body] = STATE(2764), + [sym_body] = STATE(2931), [sym_comment] = STATE(139), - [sym__block_terminator] = STATE(853), + [sym__block_terminator] = STATE(2811), [sym_include] = STATE(139), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [140] = { - [sym_body] = STATE(2765), + [sym_body] = STATE(3079), [sym_comment] = STATE(140), - [sym__block_terminator] = STATE(854), + [sym__block_terminator] = STATE(950), [sym_include] = STATE(140), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [141] = { - [sym_body] = STATE(2766), + [sym_body] = STATE(2930), [sym_comment] = STATE(141), - [sym__block_terminator] = STATE(855), + [sym__block_terminator] = STATE(2836), [sym_include] = STATE(141), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [142] = { - [sym_body] = STATE(2767), + [sym_body] = STATE(2929), [sym_comment] = STATE(142), - [sym__block_terminator] = STATE(857), + [sym__block_terminator] = STATE(2738), [sym_include] = STATE(142), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [143] = { - [sym_body] = STATE(2768), + [sym_body] = STATE(2927), [sym_comment] = STATE(143), - [sym__block_terminator] = STATE(858), + [sym__block_terminator] = STATE(2500), [sym_include] = STATE(143), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [144] = { - [sym_body] = STATE(2915), + [sym_body] = STATE(2926), [sym_comment] = STATE(144), - [sym__block_terminator] = STATE(1151), + [sym__block_terminator] = STATE(2733), [sym_include] = STATE(144), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [145] = { - [sym_body] = STATE(2769), + [sym_body] = STATE(2924), [sym_comment] = STATE(145), - [sym__block_terminator] = STATE(859), + [sym__block_terminator] = STATE(2666), [sym_include] = STATE(145), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [146] = { - [sym_body] = STATE(2770), + [sym_body] = STATE(2923), [sym_comment] = STATE(146), - [sym__block_terminator] = STATE(862), + [sym__block_terminator] = STATE(2587), [sym_include] = STATE(146), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [147] = { - [sym_body] = STATE(2772), + [sym_body] = STATE(3248), [sym_comment] = STATE(147), - [sym__block_terminator] = STATE(863), + [sym__block_terminator] = STATE(1376), [sym_include] = STATE(147), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [148] = { - [sym_body] = STATE(2774), + [sym_body] = STATE(2934), [sym_comment] = STATE(148), - [sym__block_terminator] = STATE(865), + [sym__block_terminator] = STATE(1306), [sym_include] = STATE(148), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [149] = { - [sym_body] = STATE(2919), + [sym_body] = STATE(3026), [sym_comment] = STATE(149), - [sym__block_terminator] = STATE(1180), + [sym__block_terminator] = STATE(1152), [sym_include] = STATE(149), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [150] = { + [sym_body] = STATE(2973), [sym_comment] = STATE(150), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(2515), [sym_include] = STATE(150), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(564), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1543), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(201), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [151] = { - [sym_body] = STATE(2777), + [sym_body] = STATE(3080), [sym_comment] = STATE(151), - [sym__block_terminator] = STATE(866), + [sym__block_terminator] = STATE(949), [sym_include] = STATE(151), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [152] = { - [sym_body] = STATE(2602), + [sym_body] = STATE(3081), [sym_comment] = STATE(152), - [sym__block_terminator] = STATE(2358), + [sym__block_terminator] = STATE(951), [sym_include] = STATE(152), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [153] = { - [sym_body] = STATE(2780), + [sym_body] = STATE(2979), [sym_comment] = STATE(153), - [sym__block_terminator] = STATE(869), + [sym__block_terminator] = STATE(2549), [sym_include] = STATE(153), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [154] = { - [sym_body] = STATE(2781), [sym_comment] = STATE(154), - [sym__block_terminator] = STATE(870), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(154), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(592), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1664), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(224), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [155] = { - [sym_body] = STATE(2920), + [sym_body] = STATE(3088), [sym_comment] = STATE(155), - [sym__block_terminator] = STATE(1197), + [sym__block_terminator] = STATE(952), [sym_include] = STATE(155), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [156] = { - [sym_body] = STATE(2782), + [sym_body] = STATE(2982), [sym_comment] = STATE(156), - [sym__block_terminator] = STATE(871), + [sym__block_terminator] = STATE(2553), [sym_include] = STATE(156), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [157] = { - [sym_body] = STATE(2784), + [sym_body] = STATE(2970), [sym_comment] = STATE(157), - [sym__block_terminator] = STATE(873), + [sym__block_terminator] = STATE(2499), [sym_include] = STATE(157), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [158] = { - [sym_body] = STATE(2788), + [sym_body] = STATE(2992), [sym_comment] = STATE(158), - [sym__block_terminator] = STATE(876), + [sym__block_terminator] = STATE(2559), [sym_include] = STATE(158), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [159] = { - [sym_body] = STATE(2603), + [sym_body] = STATE(2994), [sym_comment] = STATE(159), - [sym__block_terminator] = STATE(2360), + [sym__block_terminator] = STATE(2563), [sym_include] = STATE(159), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [160] = { - [sym_body] = STATE(2610), + [sym_body] = STATE(2998), [sym_comment] = STATE(160), - [sym__block_terminator] = STATE(2181), + [sym__block_terminator] = STATE(2565), [sym_include] = STATE(160), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [161] = { - [sym_body] = STATE(2787), + [sym_body] = STATE(3094), [sym_comment] = STATE(161), - [sym__block_terminator] = STATE(874), + [sym__block_terminator] = STATE(955), [sym_include] = STATE(161), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [162] = { - [sym_body] = STATE(2923), + [sym_body] = STATE(3002), [sym_comment] = STATE(162), - [sym__block_terminator] = STATE(1198), + [sym__block_terminator] = STATE(2566), [sym_include] = STATE(162), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [163] = { - [sym_body] = STATE(2789), + [sym_body] = STATE(3105), [sym_comment] = STATE(163), - [sym__block_terminator] = STATE(875), + [sym__block_terminator] = STATE(956), [sym_include] = STATE(163), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [164] = { - [sym_body] = STATE(2924), + [sym_body] = STATE(3003), [sym_comment] = STATE(164), - [sym__block_terminator] = STATE(1202), + [sym__block_terminator] = STATE(2567), [sym_include] = STATE(164), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [165] = { - [sym_body] = STATE(2793), + [sym_body] = STATE(3008), [sym_comment] = STATE(165), - [sym__block_terminator] = STATE(893), + [sym__block_terminator] = STATE(2582), [sym_include] = STATE(165), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [166] = { - [sym_body] = STATE(2794), + [sym_body] = STATE(3014), [sym_comment] = STATE(166), - [sym__block_terminator] = STATE(894), + [sym__block_terminator] = STATE(2584), [sym_include] = STATE(166), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(151), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [167] = { - [sym_body] = STATE(2806), + [sym_body] = STATE(3018), [sym_comment] = STATE(167), - [sym__block_terminator] = STATE(1209), + [sym__block_terminator] = STATE(2586), [sym_include] = STATE(167), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [168] = { - [sym_body] = STATE(2807), + [sym_body] = STATE(3110), [sym_comment] = STATE(168), - [sym__block_terminator] = STATE(1215), + [sym__block_terminator] = STATE(957), [sym_include] = STATE(168), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [169] = { - [sym_body] = STATE(2809), [sym_comment] = STATE(169), - [sym__block_terminator] = STATE(1216), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(169), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(594), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1658), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(226), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [170] = { - [sym_body] = STATE(2810), + [sym_body] = STATE(3112), [sym_comment] = STATE(170), - [sym__block_terminator] = STATE(1217), + [sym__block_terminator] = STATE(958), [sym_include] = STATE(170), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [171] = { - [sym_body] = STATE(2811), + [sym_body] = STATE(3117), [sym_comment] = STATE(171), - [sym__block_terminator] = STATE(1224), + [sym__block_terminator] = STATE(959), [sym_include] = STATE(171), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [172] = { - [sym_body] = STATE(2812), [sym_comment] = STATE(172), - [sym__block_terminator] = STATE(1225), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(172), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(589), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1676), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(228), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [173] = { - [sym_body] = STATE(2813), + [sym_body] = STATE(3122), [sym_comment] = STATE(173), - [sym__block_terminator] = STATE(1231), + [sym__block_terminator] = STATE(960), [sym_include] = STATE(173), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [174] = { - [sym_body] = STATE(2814), + [sym_body] = STATE(3361), [sym_comment] = STATE(174), - [sym__block_terminator] = STATE(1238), + [sym__block_terminator] = STATE(1195), [sym_include] = STATE(174), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [175] = { - [sym_body] = STATE(2815), + [sym_body] = STATE(3123), [sym_comment] = STATE(175), - [sym__block_terminator] = STATE(1240), + [sym__block_terminator] = STATE(962), [sym_include] = STATE(175), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [176] = { - [sym_body] = STATE(2816), + [sym_body] = STATE(3124), [sym_comment] = STATE(176), - [sym__block_terminator] = STATE(1250), + [sym__block_terminator] = STATE(963), [sym_include] = STATE(176), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [177] = { - [sym_body] = STATE(2817), + [sym_body] = STATE(3128), [sym_comment] = STATE(177), - [sym__block_terminator] = STATE(1289), + [sym__block_terminator] = STATE(966), [sym_include] = STATE(177), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [178] = { - [sym_body] = STATE(2818), + [sym_body] = STATE(3132), [sym_comment] = STATE(178), - [sym__block_terminator] = STATE(1325), + [sym__block_terminator] = STATE(967), [sym_include] = STATE(178), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [179] = { - [sym_body] = STATE(2822), + [sym_body] = STATE(3143), [sym_comment] = STATE(179), - [sym__block_terminator] = STATE(1394), + [sym__block_terminator] = STATE(968), [sym_include] = STATE(179), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [180] = { - [sym_body] = STATE(2823), + [sym_body] = STATE(3151), [sym_comment] = STATE(180), - [sym__block_terminator] = STATE(1387), + [sym__block_terminator] = STATE(969), [sym_include] = STATE(180), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [181] = { - [sym_body] = STATE(2824), + [sym_body] = STATE(3154), [sym_comment] = STATE(181), - [sym__block_terminator] = STATE(1384), + [sym__block_terminator] = STATE(971), [sym_include] = STATE(181), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [182] = { - [sym_body] = STATE(2820), + [sym_body] = STATE(3172), [sym_comment] = STATE(182), - [sym__block_terminator] = STATE(1076), + [sym__block_terminator] = STATE(972), [sym_include] = STATE(182), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [183] = { - [sym_body] = STATE(2830), + [sym_body] = STATE(3046), [sym_comment] = STATE(183), - [sym__block_terminator] = STATE(1371), + [sym__block_terminator] = STATE(2588), [sym_include] = STATE(183), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [184] = { - [sym_body] = STATE(2833), + [sym_body] = STATE(3160), [sym_comment] = STATE(184), - [sym__block_terminator] = STATE(1345), + [sym__block_terminator] = STATE(974), [sym_include] = STATE(184), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [185] = { - [sym_body] = STATE(2834), + [sym_body] = STATE(3051), [sym_comment] = STATE(185), - [sym__block_terminator] = STATE(1344), + [sym__block_terminator] = STATE(2600), [sym_include] = STATE(185), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [186] = { - [sym_body] = STATE(2835), + [sym_body] = STATE(3061), [sym_comment] = STATE(186), - [sym__block_terminator] = STATE(1362), + [sym__block_terminator] = STATE(2603), [sym_include] = STATE(186), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [187] = { - [sym_body] = STATE(2836), + [sym_body] = STATE(3330), [sym_comment] = STATE(187), - [sym__block_terminator] = STATE(1359), + [sym__block_terminator] = STATE(975), [sym_include] = STATE(187), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [188] = { - [sym_body] = STATE(2837), + [sym_body] = STATE(3173), [sym_comment] = STATE(188), - [sym__block_terminator] = STATE(1004), + [sym__block_terminator] = STATE(978), [sym_include] = STATE(188), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [189] = { - [sym_body] = STATE(2838), + [sym_body] = STATE(3066), [sym_comment] = STATE(189), - [sym__block_terminator] = STATE(1356), + [sym__block_terminator] = STATE(2605), [sym_include] = STATE(189), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [190] = { - [sym_body] = STATE(2845), + [sym_body] = STATE(3067), [sym_comment] = STATE(190), - [sym__block_terminator] = STATE(1342), + [sym__block_terminator] = STATE(2606), [sym_include] = STATE(190), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [191] = { - [sym_body] = STATE(2846), + [sym_body] = STATE(3073), [sym_comment] = STATE(191), - [sym__block_terminator] = STATE(1337), + [sym__block_terminator] = STATE(2607), [sym_include] = STATE(191), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [192] = { - [sym_body] = STATE(2849), + [sym_body] = STATE(3076), [sym_comment] = STATE(192), - [sym__block_terminator] = STATE(1320), + [sym__block_terminator] = STATE(2609), [sym_include] = STATE(192), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [193] = { - [sym_body] = STATE(2850), + [sym_body] = STATE(3174), [sym_comment] = STATE(193), - [sym__block_terminator] = STATE(1319), + [sym__block_terminator] = STATE(982), [sym_include] = STATE(193), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [194] = { - [sym_body] = STATE(2851), + [sym_body] = STATE(3176), [sym_comment] = STATE(194), - [sym__block_terminator] = STATE(1318), + [sym__block_terminator] = STATE(983), [sym_include] = STATE(194), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [195] = { - [sym_body] = STATE(2852), + [sym_body] = STATE(3179), [sym_comment] = STATE(195), - [sym__block_terminator] = STATE(1316), + [sym__block_terminator] = STATE(985), [sym_include] = STATE(195), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [196] = { - [sym_body] = STATE(2860), + [sym_body] = STATE(3180), [sym_comment] = STATE(196), - [sym__block_terminator] = STATE(1302), + [sym__block_terminator] = STATE(986), [sym_include] = STATE(196), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [197] = { - [sym_body] = STATE(2861), + [sym_body] = STATE(3181), [sym_comment] = STATE(197), - [sym__block_terminator] = STATE(1301), + [sym__block_terminator] = STATE(989), [sym_include] = STATE(197), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [198] = { - [sym_body] = STATE(2862), + [sym_body] = STATE(3182), [sym_comment] = STATE(198), - [sym__block_terminator] = STATE(1300), + [sym__block_terminator] = STATE(980), [sym_include] = STATE(198), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [199] = { - [sym_body] = STATE(2805), [sym_comment] = STATE(199), - [sym__block_terminator] = STATE(1297), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(199), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(587), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1655), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(230), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [200] = { - [sym_body] = STATE(2864), + [sym_body] = STATE(3183), [sym_comment] = STATE(200), - [sym__block_terminator] = STATE(1296), + [sym__block_terminator] = STATE(990), [sym_include] = STATE(200), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [201] = { - [sym_body] = STATE(2865), + [sym_body] = STATE(3090), [sym_comment] = STATE(201), - [sym__block_terminator] = STATE(1286), + [sym__block_terminator] = STATE(2628), [sym_include] = STATE(201), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [202] = { - [sym_body] = STATE(2925), + [sym_body] = STATE(3185), [sym_comment] = STATE(202), - [sym__block_terminator] = STATE(1003), + [sym__block_terminator] = STATE(993), [sym_include] = STATE(202), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [203] = { + [sym_body] = STATE(3103), [sym_comment] = STATE(203), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(2630), [sym_include] = STATE(203), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(559), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1556), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(205), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [204] = { - [sym_body] = STATE(2868), + [sym_body] = STATE(3115), [sym_comment] = STATE(204), - [sym__block_terminator] = STATE(1273), + [sym__block_terminator] = STATE(2629), [sym_include] = STATE(204), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [205] = { - [sym_body] = STATE(2869), + [sym_body] = STATE(3187), [sym_comment] = STATE(205), - [sym__block_terminator] = STATE(1272), + [sym__block_terminator] = STATE(996), [sym_include] = STATE(205), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [206] = { - [sym_body] = STATE(2601), + [sym_body] = STATE(3189), [sym_comment] = STATE(206), - [sym__block_terminator] = STATE(2357), + [sym__block_terminator] = STATE(992), [sym_include] = STATE(206), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [207] = { - [sym_body] = STATE(2880), + [sym_body] = STATE(3191), [sym_comment] = STATE(207), - [sym__block_terminator] = STATE(1257), + [sym__block_terminator] = STATE(999), [sym_include] = STATE(207), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [208] = { - [sym_body] = STATE(2881), + [sym_body] = STATE(3139), [sym_comment] = STATE(208), - [sym__block_terminator] = STATE(1256), + [sym__block_terminator] = STATE(2698), [sym_include] = STATE(208), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [209] = { - [sym_body] = STATE(2882), + [sym_body] = STATE(3150), [sym_comment] = STATE(209), - [sym__block_terminator] = STATE(1255), + [sym__block_terminator] = STATE(2700), [sym_include] = STATE(209), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [210] = { - [sym_body] = STATE(2883), + [sym_body] = STATE(3203), [sym_comment] = STATE(210), - [sym__block_terminator] = STATE(1254), + [sym__block_terminator] = STATE(1000), [sym_include] = STATE(210), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [211] = { - [sym_body] = STATE(2884), + [sym_body] = STATE(3208), [sym_comment] = STATE(211), - [sym__block_terminator] = STATE(1244), + [sym__block_terminator] = STATE(1003), [sym_include] = STATE(211), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [212] = { - [sym_body] = STATE(2926), [sym_comment] = STATE(212), - [sym__block_terminator] = STATE(1154), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(212), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(593), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1684), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(232), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [213] = { + [sym_body] = STATE(3190), [sym_comment] = STATE(213), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1093), [sym_include] = STATE(213), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(563), - [aux_sym_qualified_name_repeat1] = STATE(644), - [aux_sym_can_find_expression_repeat2] = STATE(1551), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(207), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), - [sym__namedot] = ACTIONS(185), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [214] = { - [sym_body] = STATE(2584), + [sym_body] = STATE(3194), [sym_comment] = STATE(214), - [sym__block_terminator] = STATE(2346), + [sym__block_terminator] = STATE(1091), [sym_include] = STATE(214), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [215] = { - [sym_body] = STATE(2930), + [sym_body] = STATE(3195), [sym_comment] = STATE(215), - [sym__block_terminator] = STATE(1236), + [sym__block_terminator] = STATE(1090), [sym_include] = STATE(215), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [216] = { - [sym_body] = STATE(2894), + [sym_body] = STATE(3198), [sym_comment] = STATE(216), - [sym__block_terminator] = STATE(1221), + [sym__block_terminator] = STATE(1089), [sym_include] = STATE(216), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [217] = { - [sym_body] = STATE(2895), + [sym_body] = STATE(3201), [sym_comment] = STATE(217), - [sym__block_terminator] = STATE(1223), + [sym__block_terminator] = STATE(1088), [sym_include] = STATE(217), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [218] = { - [sym_body] = STATE(2896), + [sym_body] = STATE(3202), [sym_comment] = STATE(218), - [sym__block_terminator] = STATE(1222), + [sym__block_terminator] = STATE(1087), [sym_include] = STATE(218), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [219] = { - [sym_body] = STATE(2961), + [sym_body] = STATE(3206), [sym_comment] = STATE(219), - [sym__block_terminator] = STATE(1113), + [sym__block_terminator] = STATE(1086), [sym_include] = STATE(219), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [220] = { - [sym_body] = STATE(2897), + [sym_body] = STATE(3211), [sym_comment] = STATE(220), - [sym__block_terminator] = STATE(1219), + [sym__block_terminator] = STATE(1085), [sym_include] = STATE(220), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [221] = { - [sym_body] = STATE(2898), + [sym_body] = STATE(3218), [sym_comment] = STATE(221), - [sym__block_terminator] = STATE(1220), + [sym__block_terminator] = STATE(1004), [sym_include] = STATE(221), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [222] = { - [sym_body] = STATE(2963), + [sym_body] = STATE(3228), [sym_comment] = STATE(222), - [sym__block_terminator] = STATE(1011), + [sym__block_terminator] = STATE(1005), [sym_include] = STATE(222), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [223] = { - [sym_body] = STATE(2913), + [sym_body] = STATE(3213), [sym_comment] = STATE(223), - [sym__block_terminator] = STATE(1189), + [sym__block_terminator] = STATE(1083), [sym_include] = STATE(223), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [224] = { - [sym_body] = STATE(2732), + [sym_body] = STATE(3217), [sym_comment] = STATE(224), - [sym__block_terminator] = STATE(1109), + [sym__block_terminator] = STATE(1082), [sym_include] = STATE(224), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [225] = { - [sym_body] = STATE(2914), + [sym_body] = STATE(3219), [sym_comment] = STATE(225), - [sym__block_terminator] = STATE(1188), + [sym__block_terminator] = STATE(1081), [sym_include] = STATE(225), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(203), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [226] = { - [sym_body] = STATE(2599), + [sym_body] = STATE(3222), [sym_comment] = STATE(226), - [sym__block_terminator] = STATE(2355), + [sym__block_terminator] = STATE(1078), [sym_include] = STATE(226), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [227] = { - [sym_body] = STATE(2597), + [sym_body] = STATE(3235), [sym_comment] = STATE(227), - [sym__block_terminator] = STATE(2353), + [sym__block_terminator] = STATE(1006), [sym_include] = STATE(227), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [228] = { - [sym_body] = STATE(2733), + [sym_body] = STATE(3245), [sym_comment] = STATE(228), - [sym__block_terminator] = STATE(1100), + [sym__block_terminator] = STATE(1007), [sym_include] = STATE(228), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [229] = { - [sym_body] = STATE(2943), + [sym_body] = STATE(3224), [sym_comment] = STATE(229), - [sym__block_terminator] = STATE(1032), + [sym__block_terminator] = STATE(1077), [sym_include] = STATE(229), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [230] = { - [sym_body] = STATE(2586), + [sym_body] = STATE(3225), [sym_comment] = STATE(230), - [sym__block_terminator] = STATE(2347), + [sym__block_terminator] = STATE(1070), [sym_include] = STATE(230), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [231] = { - [sym_body] = STATE(2965), + [sym_body] = STATE(3227), [sym_comment] = STATE(231), - [sym__block_terminator] = STATE(1050), + [sym__block_terminator] = STATE(1074), [sym_include] = STATE(231), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [232] = { - [sym_body] = STATE(2595), + [sym_body] = STATE(3074), [sym_comment] = STATE(232), - [sym__block_terminator] = STATE(2350), + [sym__block_terminator] = STATE(1154), [sym_include] = STATE(232), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [233] = { - [sym_body] = STATE(2960), + [sym_body] = STATE(3230), [sym_comment] = STATE(233), - [sym__block_terminator] = STATE(1067), + [sym__block_terminator] = STATE(1071), [sym_include] = STATE(233), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [234] = { - [sym_body] = STATE(2590), + [sym_body] = STATE(3233), [sym_comment] = STATE(234), - [sym__block_terminator] = STATE(2348), + [sym__block_terminator] = STATE(1068), [sym_include] = STATE(234), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [235] = { - [sym_body] = STATE(2803), + [sym_body] = STATE(3236), [sym_comment] = STATE(235), - [sym__block_terminator] = STATE(1156), + [sym__block_terminator] = STATE(1059), [sym_include] = STATE(235), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [236] = { - [sym_body] = STATE(2958), + [sym_body] = STATE(2971), [sym_comment] = STATE(236), - [sym__block_terminator] = STATE(1080), + [sym__block_terminator] = STATE(2508), [sym_include] = STATE(236), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(174), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [237] = { - [sym_body] = STATE(2736), + [sym_body] = STATE(3237), [sym_comment] = STATE(237), - [sym__block_terminator] = STATE(1163), + [sym__block_terminator] = STATE(1067), [sym_include] = STATE(237), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [238] = { - [sym_body] = STATE(2737), + [sym_body] = STATE(3249), [sym_comment] = STATE(238), - [sym__block_terminator] = STATE(1147), + [sym__block_terminator] = STATE(1064), [sym_include] = STATE(238), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [239] = { - [sym_body] = STATE(2956), + [sym_body] = STATE(3251), [sym_comment] = STATE(239), - [sym__block_terminator] = STATE(1094), + [sym__block_terminator] = STATE(1063), [sym_include] = STATE(239), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [240] = { - [sym_body] = STATE(2591), + [sym_body] = STATE(3261), [sym_comment] = STATE(240), - [sym__block_terminator] = STATE(2349), + [sym__block_terminator] = STATE(1061), [sym_include] = STATE(240), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(155), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [241] = { - [sym_body] = STATE(2955), + [sym_body] = STATE(3262), [sym_comment] = STATE(241), - [sym__block_terminator] = STATE(1101), + [sym__block_terminator] = STATE(1060), [sym_include] = STATE(241), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [242] = { - [sym_body] = STATE(2953), + [sym_body] = STATE(3269), [sym_comment] = STATE(242), - [sym__block_terminator] = STATE(1111), + [sym__block_terminator] = STATE(1057), [sym_include] = STATE(242), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [243] = { - [sym_body] = STATE(2952), + [sym_body] = STATE(3247), [sym_comment] = STATE(243), - [sym__block_terminator] = STATE(1115), + [sym__block_terminator] = STATE(1008), [sym_include] = STATE(243), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [244] = { - [sym_body] = STATE(2949), + [sym_body] = STATE(3256), [sym_comment] = STATE(244), - [sym__block_terminator] = STATE(1122), + [sym__block_terminator] = STATE(1009), [sym_include] = STATE(244), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [245] = { - [sym_body] = STATE(2948), + [sym_body] = STATE(3016), [sym_comment] = STATE(245), - [sym__block_terminator] = STATE(1125), + [sym__block_terminator] = STATE(1157), [sym_include] = STATE(245), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [246] = { - [sym_body] = STATE(2946), + [sym_body] = STATE(3015), [sym_comment] = STATE(246), - [sym__block_terminator] = STATE(1130), + [sym__block_terminator] = STATE(1155), [sym_include] = STATE(246), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [247] = { - [sym_body] = STATE(2945), + [sym_body] = STATE(3272), [sym_comment] = STATE(247), - [sym__block_terminator] = STATE(1132), + [sym__block_terminator] = STATE(1053), [sym_include] = STATE(247), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [248] = { - [sym_body] = STATE(2944), + [sym_body] = STATE(3263), [sym_comment] = STATE(248), - [sym__block_terminator] = STATE(1136), + [sym__block_terminator] = STATE(1010), [sym_include] = STATE(248), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(187), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [249] = { - [sym_body] = STATE(3220), + [sym_body] = STATE(3283), [sym_comment] = STATE(249), + [sym__block_terminator] = STATE(1052), [sym_include] = STATE(249), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(209), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [250] = { - [sym_body] = STATE(3172), + [sym_body] = STATE(3285), [sym_comment] = STATE(250), + [sym__block_terminator] = STATE(1051), [sym_include] = STATE(250), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(211), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [251] = { - [sym_body] = STATE(2998), + [sym_body] = STATE(3162), [sym_comment] = STATE(251), + [sym__block_terminator] = STATE(1050), [sym_include] = STATE(251), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(213), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [252] = { - [sym_body] = STATE(3083), + [sym_body] = STATE(3364), [sym_comment] = STATE(252), + [sym__block_terminator] = STATE(1030), [sym_include] = STATE(252), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(215), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [253] = { - [sym_body] = STATE(3127), + [sym_body] = STATE(3301), [sym_comment] = STATE(253), + [sym__block_terminator] = STATE(1047), [sym_include] = STATE(253), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(217), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [254] = { - [sym_body] = STATE(3176), + [sym_body] = STATE(3303), [sym_comment] = STATE(254), + [sym__block_terminator] = STATE(1046), [sym_include] = STATE(254), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(219), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [255] = { - [sym_body] = STATE(3149), + [sym_body] = STATE(3304), [sym_comment] = STATE(255), + [sym__block_terminator] = STATE(1045), [sym_include] = STATE(255), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(221), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [256] = { - [sym_body] = STATE(3142), + [sym_body] = STATE(3306), [sym_comment] = STATE(256), + [sym__block_terminator] = STATE(1044), [sym_include] = STATE(256), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(223), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [257] = { - [sym_body] = STATE(3085), + [sym_body] = STATE(3312), [sym_comment] = STATE(257), + [sym__block_terminator] = STATE(1042), [sym_include] = STATE(257), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(225), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [258] = { - [sym_body] = STATE(3026), + [sym_body] = STATE(3313), [sym_comment] = STATE(258), + [sym__block_terminator] = STATE(1041), [sym_include] = STATE(258), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(227), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [259] = { - [sym_body] = STATE(3208), + [sym_body] = STATE(3340), [sym_comment] = STATE(259), + [sym__block_terminator] = STATE(1037), [sym_include] = STATE(259), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(229), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [260] = { - [sym_body] = STATE(3180), + [sym_body] = STATE(3320), [sym_comment] = STATE(260), + [sym__block_terminator] = STATE(1039), [sym_include] = STATE(260), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(261), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(231), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [261] = { + [sym_body] = STATE(3266), [sym_comment] = STATE(261), + [sym__block_terminator] = STATE(1011), [sym_include] = STATE(261), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(264), - [sym_identifier] = ACTIONS(55), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(233), - [aux_sym_input_expression_token1] = ACTIONS(59), - [aux_sym_variable_definition_token1] = ACTIONS(61), - [aux_sym_variable_definition_token2] = ACTIONS(63), - [aux_sym_buffer_definition_token2] = ACTIONS(65), - [aux_sym_argument_mode_token1] = ACTIONS(67), - [aux_sym_if_statement_token1] = ACTIONS(69), - [aux_sym_repeat_statement_token1] = ACTIONS(71), - [aux_sym_do_while_statement_token1] = ACTIONS(73), - [aux_sym__procedure_terminator_token1] = ACTIONS(75), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(77), - [aux_sym__function_terminator_token1] = ACTIONS(79), - [aux_sym_class_statement_token1] = ACTIONS(81), - [aux_sym_on_error_phrase_token1] = ACTIONS(83), - [aux_sym_on_error_phrase_token3] = ACTIONS(85), - [aux_sym__case_terminator_token1] = ACTIONS(87), - [aux_sym_find_statement_token1] = ACTIONS(89), - [aux_sym_assign_statement_token1] = ACTIONS(91), - [aux_sym_catch_statement_token1] = ACTIONS(93), - [aux_sym_finally_statement_token1] = ACTIONS(95), - [aux_sym_accumulate_statement_token1] = ACTIONS(97), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(99), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(99), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [262] = { [sym_comment] = STATE(262), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(262), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(562), - [aux_sym_can_find_expression_repeat2] = STATE(1559), - [sym_identifier] = ACTIONS(101), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(591), + [aux_sym_qualified_name_repeat1] = STATE(678), + [aux_sym_can_find_expression_repeat2] = STATE(1682), + [sym_identifier] = ACTIONS(126), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(191), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(234), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + [sym__namedot] = ACTIONS(212), }, [263] = { + [sym_body] = STATE(3267), [sym_comment] = STATE(263), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1013), [sym_include] = STATE(263), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(564), - [aux_sym_can_find_expression_repeat2] = STATE(1543), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(201), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [264] = { + [sym_body] = STATE(3277), [sym_comment] = STATE(264), + [sym__block_terminator] = STATE(1015), [sym_include] = STATE(264), - [sym_assignment] = STATE(3008), - [sym_variable_definition] = STATE(1139), - [sym_variable_assignment] = STATE(1139), - [sym_buffer_definition] = STATE(1139), - [sym_query_definition] = STATE(1139), - [sym_function_call_statement] = STATE(1139), - [sym_function_call] = STATE(2987), - [sym_if_statement] = STATE(1139), - [sym_label] = STATE(1140), - [sym__loop_statement] = STATE(1139), - [sym_repeat_statement] = STATE(1141), - [sym_do_while_statement] = STATE(1141), - [sym_do_statement] = STATE(1141), - [sym_procedure_statement] = STATE(1139), - [sym_procedure_parameter_definition] = STATE(1139), - [sym_function_statement] = STATE(1139), - [sym_return_statement] = STATE(1139), - [sym_class_statement] = STATE(1139), - [sym_stream_definition] = STATE(1139), - [sym_input_close_statement] = STATE(1139), - [sym_output_close_statement] = STATE(1139), - [sym__stream_statement] = STATE(1139), - [sym_input_stream_statement] = STATE(1142), - [sym_output_stream_statement] = STATE(1142), - [sym_do_block] = STATE(1139), - [sym_case_statement] = STATE(1139), - [sym_for_statement] = STATE(1139), - [sym_find_statement] = STATE(1139), - [sym_transaction_statement] = STATE(1139), - [sym_abl_statement] = STATE(1139), - [sym_assign_statement] = STATE(1139), - [sym_catch_statement] = STATE(1139), - [sym_finally_statement] = STATE(1139), - [sym_accumulate_statement] = STATE(1139), - [sym_undo_statement] = STATE(1139), - [sym_error_scope_statement] = STATE(1139), - [sym_temp_table_definition] = STATE(1139), - [sym_on_statement] = STATE(1139), - [sym__statement] = STATE(1143), - [aux_sym_source_code_repeat1] = STATE(264), - [sym_identifier] = ACTIONS(235), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym__block_terminator_token1] = ACTIONS(238), - [aux_sym_input_expression_token1] = ACTIONS(240), - [aux_sym_variable_definition_token1] = ACTIONS(243), - [aux_sym_variable_definition_token2] = ACTIONS(246), - [aux_sym_buffer_definition_token2] = ACTIONS(249), - [aux_sym_argument_mode_token1] = ACTIONS(252), - [aux_sym_if_statement_token1] = ACTIONS(255), - [aux_sym_repeat_statement_token1] = ACTIONS(258), - [aux_sym_do_while_statement_token1] = ACTIONS(261), - [aux_sym__procedure_terminator_token1] = ACTIONS(264), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(267), - [aux_sym__function_terminator_token1] = ACTIONS(270), - [aux_sym_class_statement_token1] = ACTIONS(273), - [aux_sym_on_error_phrase_token1] = ACTIONS(276), - [aux_sym_on_error_phrase_token3] = ACTIONS(279), - [aux_sym__case_terminator_token1] = ACTIONS(282), - [aux_sym_find_statement_token1] = ACTIONS(285), - [aux_sym_assign_statement_token1] = ACTIONS(288), - [aux_sym_catch_statement_token1] = ACTIONS(291), - [aux_sym_finally_statement_token1] = ACTIONS(294), - [aux_sym_accumulate_statement_token1] = ACTIONS(297), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(300), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(300), + [aux_sym__block_terminator_token1] = ACTIONS(176), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [265] = { + [sym_body] = STATE(3334), [sym_comment] = STATE(265), + [sym__block_terminator] = STATE(1038), [sym_include] = STATE(265), - [sym_assignment] = STATE(3302), - [sym_variable_definition] = STATE(1044), - [sym_variable_assignment] = STATE(1044), - [sym_buffer_definition] = STATE(1044), - [sym_query_definition] = STATE(1044), - [sym_function_call_statement] = STATE(1044), - [sym_function_call] = STATE(3301), - [sym_if_statement] = STATE(1044), - [sym_label] = STATE(1049), - [sym__loop_statement] = STATE(1044), - [sym_repeat_statement] = STATE(1054), - [sym_do_while_statement] = STATE(1054), - [sym_do_statement] = STATE(1054), - [sym_procedure_statement] = STATE(1044), - [sym_procedure_parameter_definition] = STATE(1044), - [sym_function_statement] = STATE(1044), - [sym_return_statement] = STATE(1044), - [sym_class_statement] = STATE(1044), - [sym_stream_definition] = STATE(1044), - [sym_input_close_statement] = STATE(1044), - [sym_output_close_statement] = STATE(1044), - [sym__stream_statement] = STATE(1044), - [sym_input_stream_statement] = STATE(1055), - [sym_output_stream_statement] = STATE(1055), - [sym_do_block] = STATE(1044), - [sym_case_statement] = STATE(1044), - [sym_for_statement] = STATE(1044), - [sym_find_statement] = STATE(1044), - [sym_transaction_statement] = STATE(1044), - [sym_abl_statement] = STATE(1044), - [sym_assign_statement] = STATE(1044), - [sym_catch_statement] = STATE(1044), - [sym_finally_statement] = STATE(1044), - [sym_accumulate_statement] = STATE(1044), - [sym_undo_statement] = STATE(1044), - [sym_error_scope_statement] = STATE(1044), - [sym_temp_table_definition] = STATE(1044), - [sym_on_statement] = STATE(1044), - [sym__statement] = STATE(1059), - [aux_sym_source_code_repeat1] = STATE(265), - [ts_builtin_sym_end] = ACTIONS(303), - [sym_identifier] = ACTIONS(305), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym_input_expression_token1] = ACTIONS(308), - [aux_sym_variable_definition_token1] = ACTIONS(311), - [aux_sym_variable_definition_token2] = ACTIONS(314), - [aux_sym_buffer_definition_token2] = ACTIONS(317), - [aux_sym_argument_mode_token1] = ACTIONS(320), - [aux_sym_if_statement_token1] = ACTIONS(323), - [aux_sym_repeat_statement_token1] = ACTIONS(326), - [aux_sym_do_while_statement_token1] = ACTIONS(329), - [aux_sym__procedure_terminator_token1] = ACTIONS(332), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(335), - [aux_sym__function_terminator_token1] = ACTIONS(338), - [aux_sym_class_statement_token1] = ACTIONS(341), - [aux_sym_on_error_phrase_token1] = ACTIONS(344), - [aux_sym_on_error_phrase_token3] = ACTIONS(347), - [aux_sym__case_terminator_token1] = ACTIONS(350), - [aux_sym_find_statement_token1] = ACTIONS(353), - [aux_sym_assign_statement_token1] = ACTIONS(356), - [aux_sym_catch_statement_token1] = ACTIONS(359), - [aux_sym_finally_statement_token1] = ACTIONS(362), - [aux_sym_accumulate_statement_token1] = ACTIONS(365), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(368), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(368), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [266] = { + [sym_body] = STATE(3118), [sym_comment] = STATE(266), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1123), [sym_include] = STATE(266), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(555), - [aux_sym_can_find_expression_repeat2] = STATE(1565), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(193), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(178), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [267] = { + [sym_body] = STATE(3368), [sym_comment] = STATE(267), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), + [sym__block_terminator] = STATE(1028), [sym_include] = STATE(267), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(560), - [aux_sym_can_find_expression_repeat2] = STATE(1557), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(199), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(180), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [268] = { + [sym_body] = STATE(3796), [sym_comment] = STATE(268), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(268), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(557), - [aux_sym_can_find_expression_repeat2] = STATE(1553), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(189), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(236), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [269] = { + [sym_body] = STATE(3449), [sym_comment] = STATE(269), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(269), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(563), - [aux_sym_can_find_expression_repeat2] = STATE(1551), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(207), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(238), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [270] = { + [sym_body] = STATE(3504), [sym_comment] = STATE(270), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(270), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(559), - [aux_sym_can_find_expression_repeat2] = STATE(1556), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(205), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(240), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [271] = { + [sym_body] = STATE(3672), [sym_comment] = STATE(271), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(271), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(556), - [aux_sym_can_find_expression_repeat2] = STATE(1561), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(157), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(242), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [272] = { + [sym_body] = STATE(3633), [sym_comment] = STATE(272), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(272), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(561), - [aux_sym_can_find_expression_repeat2] = STATE(1552), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(195), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(244), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [273] = { + [sym_body] = STATE(3592), [sym_comment] = STATE(273), - [sym_constant] = STATE(310), - [sym_qualified_name] = STATE(310), - [sym_boolean_literal] = STATE(310), - [sym__decimal_literal] = STATE(284), - [sym_number_literal] = STATE(310), - [sym__string_literal] = STATE(310), - [sym_double_quoted_string] = STATE(282), - [sym_single_quoted_string] = STATE(282), - [sym_parenthesized_expression] = STATE(310), - [sym_logical_expression] = STATE(312), - [sym_unary_expression] = STATE(310), - [sym_ambiguous_expression] = STATE(310), - [sym_current_changed_expression] = STATE(310), - [sym_locked_expression] = STATE(310), - [sym_input_expression] = STATE(310), - [sym_additive_expression] = STATE(312), - [sym_multiplicative_expression] = STATE(312), - [sym_comparison_expression] = STATE(312), - [sym__binary_expression] = STATE(310), [sym_include] = STATE(273), - [sym_function_call] = STATE(310), - [sym_ternary_expression] = STATE(310), - [sym_new_expression] = STATE(310), - [sym_object_access] = STATE(310), - [sym_where_clause] = STATE(1708), - [sym_query_tuning] = STATE(1708), - [sym_can_find_expression] = STATE(310), - [sym_of] = STATE(1708), - [sym__using_first] = STATE(1576), - [sym_accumulate_expression] = STATE(310), - [sym_available_expression] = STATE(310), - [sym__expression] = STATE(558), - [aux_sym_can_find_expression_repeat2] = STATE(1548), - [sym_identifier] = ACTIONS(101), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), - [anon_sym_LBRACE] = ACTIONS(103), - [sym_null_expression] = ACTIONS(105), - [aux_sym_boolean_literal_token1] = ACTIONS(107), - [aux_sym_boolean_literal_token2] = ACTIONS(107), - [aux_sym_boolean_literal_token3] = ACTIONS(107), - [aux_sym_boolean_literal_token4] = ACTIONS(107), - [sym__integer_literal] = ACTIONS(109), - [anon_sym_DQUOTE] = ACTIONS(111), - [anon_sym_SQUOTE] = ACTIONS(113), - [anon_sym_LPAREN] = ACTIONS(115), - [anon_sym_RPAREN] = ACTIONS(197), - [aux_sym_unary_expression_token1] = ACTIONS(119), - [aux_sym_unary_expression_token2] = ACTIONS(159), - [aux_sym_ambiguous_expression_token1] = ACTIONS(161), - [aux_sym_current_changed_expression_token1] = ACTIONS(163), - [aux_sym_locked_expression_token1] = ACTIONS(165), - [aux_sym_input_expression_token1] = ACTIONS(167), - [aux_sym_scope_tuning_token1] = ACTIONS(169), - [aux_sym_if_statement_token1] = ACTIONS(171), - [aux_sym_where_clause_token1] = ACTIONS(173), - [aux_sym_query_tuning_token1] = ACTIONS(175), - [aux_sym_query_tuning_token2] = ACTIONS(175), - [aux_sym_query_tuning_token3] = ACTIONS(175), - [aux_sym_query_tuning_token4] = ACTIONS(175), - [aux_sym_query_tuning_token5] = ACTIONS(175), - [aux_sym_query_tuning_token6] = ACTIONS(177), - [aux_sym_can_find_expression_token1] = ACTIONS(137), - [aux_sym_of_token1] = ACTIONS(179), - [aux_sym__using_first_token1] = ACTIONS(181), - [aux_sym_accumulate_expression_token1] = ACTIONS(183), - [aux_sym_available_expression_token1] = ACTIONS(143), - [aux_sym_available_expression_token2] = ACTIONS(143), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(246), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [274] = { + [sym_body] = STATE(3560), [sym_comment] = STATE(274), [sym_include] = STATE(274), - [sym_assignment] = STATE(3302), - [sym_variable_definition] = STATE(1044), - [sym_variable_assignment] = STATE(1044), - [sym_buffer_definition] = STATE(1044), - [sym_query_definition] = STATE(1044), - [sym_function_call_statement] = STATE(1044), - [sym_function_call] = STATE(3301), - [sym_if_statement] = STATE(1044), - [sym_label] = STATE(1049), - [sym__loop_statement] = STATE(1044), - [sym_repeat_statement] = STATE(1054), - [sym_do_while_statement] = STATE(1054), - [sym_do_statement] = STATE(1054), - [sym_procedure_statement] = STATE(1044), - [sym_procedure_parameter_definition] = STATE(1044), - [sym_function_statement] = STATE(1044), - [sym_return_statement] = STATE(1044), - [sym_class_statement] = STATE(1044), - [sym_stream_definition] = STATE(1044), - [sym_input_close_statement] = STATE(1044), - [sym_output_close_statement] = STATE(1044), - [sym__stream_statement] = STATE(1044), - [sym_input_stream_statement] = STATE(1055), - [sym_output_stream_statement] = STATE(1055), - [sym_do_block] = STATE(1044), - [sym_case_statement] = STATE(1044), - [sym_for_statement] = STATE(1044), - [sym_find_statement] = STATE(1044), - [sym_transaction_statement] = STATE(1044), - [sym_abl_statement] = STATE(1044), - [sym_assign_statement] = STATE(1044), - [sym_catch_statement] = STATE(1044), - [sym_finally_statement] = STATE(1044), - [sym_accumulate_statement] = STATE(1044), - [sym_undo_statement] = STATE(1044), - [sym_error_scope_statement] = STATE(1044), - [sym_temp_table_definition] = STATE(1044), - [sym_on_statement] = STATE(1044), - [sym__statement] = STATE(1059), - [aux_sym_source_code_repeat1] = STATE(265), - [ts_builtin_sym_end] = ACTIONS(371), - [sym_identifier] = ACTIONS(11), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), [anon_sym_SLASH_SLASH] = ACTIONS(3), [anon_sym_SLASH_STAR] = ACTIONS(5), [anon_sym_LBRACE] = ACTIONS(7), - [aux_sym_input_expression_token1] = ACTIONS(13), - [aux_sym_variable_definition_token1] = ACTIONS(15), - [aux_sym_variable_definition_token2] = ACTIONS(17), - [aux_sym_buffer_definition_token2] = ACTIONS(19), - [aux_sym_argument_mode_token1] = ACTIONS(21), - [aux_sym_if_statement_token1] = ACTIONS(23), - [aux_sym_repeat_statement_token1] = ACTIONS(25), - [aux_sym_do_while_statement_token1] = ACTIONS(27), - [aux_sym__procedure_terminator_token1] = ACTIONS(29), - [aux_sym_procedure_parameter_definition_token1] = ACTIONS(31), - [aux_sym__function_terminator_token1] = ACTIONS(33), - [aux_sym_class_statement_token1] = ACTIONS(35), - [aux_sym_on_error_phrase_token1] = ACTIONS(37), - [aux_sym_on_error_phrase_token3] = ACTIONS(39), - [aux_sym__case_terminator_token1] = ACTIONS(41), - [aux_sym_find_statement_token1] = ACTIONS(43), - [aux_sym_assign_statement_token1] = ACTIONS(45), - [aux_sym_catch_statement_token1] = ACTIONS(47), - [aux_sym_finally_statement_token1] = ACTIONS(49), - [aux_sym_accumulate_statement_token1] = ACTIONS(51), - [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(53), - [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(53), + [aux_sym__block_terminator_token1] = ACTIONS(248), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [275] = { + [sym_body] = STATE(3528), [sym_comment] = STATE(275), [sym_include] = STATE(275), - [aux_sym_qualified_name_repeat1] = STATE(276), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(377), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(381), - [anon_sym_LPAREN] = ACTIONS(381), - [anon_sym_RPAREN] = ACTIONS(381), - [aux_sym__logical_operator_token1] = ACTIONS(381), - [aux_sym__logical_operator_token2] = ACTIONS(381), - [aux_sym__logical_operator_token3] = ACTIONS(381), - [aux_sym__logical_operator_token4] = ACTIONS(381), - [aux_sym__logical_operator_token5] = ACTIONS(381), - [aux_sym__logical_operator_token6] = ACTIONS(381), - [aux_sym_input_expression_token2] = ACTIONS(381), - [anon_sym_PLUS] = ACTIONS(381), - [anon_sym_DASH] = ACTIONS(381), - [anon_sym_STAR] = ACTIONS(381), - [anon_sym_LT] = ACTIONS(377), - [anon_sym_LT_EQ] = ACTIONS(381), - [anon_sym_LT_GT] = ACTIONS(381), - [anon_sym_EQ] = ACTIONS(381), - [anon_sym_GT] = ACTIONS(377), - [anon_sym_GT_EQ] = ACTIONS(381), - [aux_sym__comparison_operator_token1] = ACTIONS(381), - [aux_sym__comparison_operator_token2] = ACTIONS(381), - [aux_sym__comparison_operator_token3] = ACTIONS(381), - [aux_sym__comparison_operator_token4] = ACTIONS(381), - [aux_sym__comparison_operator_token5] = ACTIONS(381), - [aux_sym__comparison_operator_token6] = ACTIONS(381), - [aux_sym__comparison_operator_token7] = ACTIONS(381), - [aux_sym__comparison_operator_token8] = ACTIONS(381), - [aux_sym__comparison_operator_token9] = ACTIONS(381), - [aux_sym_variable_tuning_token1] = ACTIONS(381), - [aux_sym_variable_tuning_token2] = ACTIONS(381), - [aux_sym_variable_tuning_token3] = ACTIONS(381), - [aux_sym_variable_tuning_token4] = ACTIONS(381), - [aux_sym_variable_tuning_token5] = ACTIONS(381), - [aux_sym_variable_tuning_token6] = ACTIONS(381), - [aux_sym_serialization_tuning_token1] = ACTIONS(381), - [anon_sym_COMMA] = ACTIONS(381), - [aux_sym_if_statement_token2] = ACTIONS(381), - [aux_sym_else_if_statement_token1] = ACTIONS(381), - [anon_sym_COLON] = ACTIONS(381), - [aux_sym_do_while_statement_token1] = ACTIONS(381), - [aux_sym_do_statement_token1] = ACTIONS(381), - [aux_sym_class_statement_token2] = ACTIONS(381), - [aux_sym_implements_token1] = ACTIONS(381), - [aux_sym_use_widget_pool_token1] = ACTIONS(381), - [aux_sym_abstract_token1] = ACTIONS(381), - [aux_sym_final_token1] = ACTIONS(381), - [aux_sym_on_error_phrase_token1] = ACTIONS(381), - [aux_sym_where_clause_token1] = ACTIONS(381), - [aux_sym_query_tuning_token1] = ACTIONS(381), - [aux_sym_query_tuning_token2] = ACTIONS(381), - [aux_sym_query_tuning_token3] = ACTIONS(381), - [aux_sym_query_tuning_token4] = ACTIONS(381), - [aux_sym_query_tuning_token5] = ACTIONS(381), - [aux_sym_query_tuning_token6] = ACTIONS(381), - [aux_sym_sort_clause_token1] = ACTIONS(381), - [aux_sym_sort_clause_token2] = ACTIONS(381), - [aux_sym_of_token1] = ACTIONS(381), - [aux_sym__using_first_token1] = ACTIONS(381), - [aux_sym_widget_field_token1] = ACTIONS(377), - [aux_sym_on_statement_token1] = ACTIONS(381), - [sym__namedot] = ACTIONS(383), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(250), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [276] = { + [sym_body] = STATE(3621), [sym_comment] = STATE(276), [sym_include] = STATE(276), - [aux_sym_qualified_name_repeat1] = STATE(276), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(385), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(387), - [anon_sym_LPAREN] = ACTIONS(387), - [anon_sym_RPAREN] = ACTIONS(387), - [aux_sym__logical_operator_token1] = ACTIONS(387), - [aux_sym__logical_operator_token2] = ACTIONS(387), - [aux_sym__logical_operator_token3] = ACTIONS(387), - [aux_sym__logical_operator_token4] = ACTIONS(387), - [aux_sym__logical_operator_token5] = ACTIONS(387), - [aux_sym__logical_operator_token6] = ACTIONS(387), - [aux_sym_input_expression_token2] = ACTIONS(387), - [anon_sym_PLUS] = ACTIONS(387), - [anon_sym_DASH] = ACTIONS(387), - [anon_sym_STAR] = ACTIONS(387), - [anon_sym_LT] = ACTIONS(385), - [anon_sym_LT_EQ] = ACTIONS(387), - [anon_sym_LT_GT] = ACTIONS(387), - [anon_sym_EQ] = ACTIONS(387), - [anon_sym_GT] = ACTIONS(385), - [anon_sym_GT_EQ] = ACTIONS(387), - [aux_sym__comparison_operator_token1] = ACTIONS(387), - [aux_sym__comparison_operator_token2] = ACTIONS(387), - [aux_sym__comparison_operator_token3] = ACTIONS(387), - [aux_sym__comparison_operator_token4] = ACTIONS(387), - [aux_sym__comparison_operator_token5] = ACTIONS(387), - [aux_sym__comparison_operator_token6] = ACTIONS(387), - [aux_sym__comparison_operator_token7] = ACTIONS(387), - [aux_sym__comparison_operator_token8] = ACTIONS(387), - [aux_sym__comparison_operator_token9] = ACTIONS(387), - [aux_sym_variable_tuning_token1] = ACTIONS(387), - [aux_sym_variable_tuning_token2] = ACTIONS(387), - [aux_sym_variable_tuning_token3] = ACTIONS(387), - [aux_sym_variable_tuning_token4] = ACTIONS(387), - [aux_sym_variable_tuning_token5] = ACTIONS(387), - [aux_sym_variable_tuning_token6] = ACTIONS(387), - [aux_sym_serialization_tuning_token1] = ACTIONS(387), - [anon_sym_COMMA] = ACTIONS(387), - [aux_sym_if_statement_token2] = ACTIONS(387), - [aux_sym_else_if_statement_token1] = ACTIONS(387), - [anon_sym_COLON] = ACTIONS(387), - [aux_sym_do_while_statement_token1] = ACTIONS(387), - [aux_sym_do_statement_token1] = ACTIONS(387), - [aux_sym_class_statement_token2] = ACTIONS(387), - [aux_sym_implements_token1] = ACTIONS(387), - [aux_sym_use_widget_pool_token1] = ACTIONS(387), - [aux_sym_abstract_token1] = ACTIONS(387), - [aux_sym_final_token1] = ACTIONS(387), - [aux_sym_on_error_phrase_token1] = ACTIONS(387), - [aux_sym_where_clause_token1] = ACTIONS(387), - [aux_sym_query_tuning_token1] = ACTIONS(387), - [aux_sym_query_tuning_token2] = ACTIONS(387), - [aux_sym_query_tuning_token3] = ACTIONS(387), - [aux_sym_query_tuning_token4] = ACTIONS(387), - [aux_sym_query_tuning_token5] = ACTIONS(387), - [aux_sym_query_tuning_token6] = ACTIONS(387), - [aux_sym_sort_clause_token1] = ACTIONS(387), - [aux_sym_sort_clause_token2] = ACTIONS(387), - [aux_sym_of_token1] = ACTIONS(387), - [aux_sym__using_first_token1] = ACTIONS(387), - [aux_sym_widget_field_token1] = ACTIONS(385), - [aux_sym_on_statement_token1] = ACTIONS(387), - [sym__namedot] = ACTIONS(389), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(252), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [277] = { + [sym_body] = STATE(3569), [sym_comment] = STATE(277), [sym_include] = STATE(277), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(385), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(387), - [anon_sym_LPAREN] = ACTIONS(387), - [anon_sym_RPAREN] = ACTIONS(387), - [aux_sym__logical_operator_token1] = ACTIONS(387), - [aux_sym__logical_operator_token2] = ACTIONS(387), - [aux_sym__logical_operator_token3] = ACTIONS(387), - [aux_sym__logical_operator_token4] = ACTIONS(387), - [aux_sym__logical_operator_token5] = ACTIONS(387), - [aux_sym__logical_operator_token6] = ACTIONS(387), - [aux_sym_input_expression_token2] = ACTIONS(387), - [anon_sym_PLUS] = ACTIONS(387), - [anon_sym_DASH] = ACTIONS(387), - [anon_sym_STAR] = ACTIONS(387), - [anon_sym_LT] = ACTIONS(385), - [anon_sym_LT_EQ] = ACTIONS(387), - [anon_sym_LT_GT] = ACTIONS(387), - [anon_sym_EQ] = ACTIONS(387), - [anon_sym_GT] = ACTIONS(385), - [anon_sym_GT_EQ] = ACTIONS(387), - [aux_sym__comparison_operator_token1] = ACTIONS(387), - [aux_sym__comparison_operator_token2] = ACTIONS(387), - [aux_sym__comparison_operator_token3] = ACTIONS(387), - [aux_sym__comparison_operator_token4] = ACTIONS(387), - [aux_sym__comparison_operator_token5] = ACTIONS(387), - [aux_sym__comparison_operator_token6] = ACTIONS(387), - [aux_sym__comparison_operator_token7] = ACTIONS(387), - [aux_sym__comparison_operator_token8] = ACTIONS(387), - [aux_sym__comparison_operator_token9] = ACTIONS(387), - [aux_sym_variable_tuning_token1] = ACTIONS(387), - [aux_sym_variable_tuning_token2] = ACTIONS(387), - [aux_sym_variable_tuning_token3] = ACTIONS(387), - [aux_sym_variable_tuning_token4] = ACTIONS(387), - [aux_sym_variable_tuning_token5] = ACTIONS(387), - [aux_sym_variable_tuning_token6] = ACTIONS(387), - [aux_sym_serialization_tuning_token1] = ACTIONS(387), - [anon_sym_COMMA] = ACTIONS(387), - [aux_sym_if_statement_token2] = ACTIONS(387), - [aux_sym_else_if_statement_token1] = ACTIONS(387), - [anon_sym_COLON] = ACTIONS(387), - [aux_sym_do_while_statement_token1] = ACTIONS(387), - [aux_sym_do_statement_token1] = ACTIONS(387), - [aux_sym_class_statement_token2] = ACTIONS(387), - [aux_sym_implements_token1] = ACTIONS(387), - [aux_sym_use_widget_pool_token1] = ACTIONS(387), - [aux_sym_abstract_token1] = ACTIONS(387), - [aux_sym_final_token1] = ACTIONS(387), - [aux_sym_on_error_phrase_token1] = ACTIONS(387), - [aux_sym_where_clause_token1] = ACTIONS(387), - [aux_sym_query_tuning_token1] = ACTIONS(387), - [aux_sym_query_tuning_token2] = ACTIONS(387), - [aux_sym_query_tuning_token3] = ACTIONS(387), - [aux_sym_query_tuning_token4] = ACTIONS(387), - [aux_sym_query_tuning_token5] = ACTIONS(387), - [aux_sym_query_tuning_token6] = ACTIONS(387), - [aux_sym_sort_clause_token1] = ACTIONS(387), - [aux_sym_sort_clause_token2] = ACTIONS(387), - [aux_sym_of_token1] = ACTIONS(387), - [aux_sym__using_first_token1] = ACTIONS(387), - [aux_sym_widget_field_token1] = ACTIONS(385), - [aux_sym_on_statement_token1] = ACTIONS(387), - [sym__namedot] = ACTIONS(387), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(286), + [sym_identifier] = ACTIONS(76), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(254), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), }, [278] = { [sym_comment] = STATE(278), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(278), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(392), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(394), - [anon_sym_LPAREN] = ACTIONS(394), - [anon_sym_RPAREN] = ACTIONS(394), - [aux_sym__logical_operator_token1] = ACTIONS(394), - [aux_sym__logical_operator_token2] = ACTIONS(394), - [aux_sym__logical_operator_token3] = ACTIONS(394), - [aux_sym__logical_operator_token4] = ACTIONS(394), - [aux_sym__logical_operator_token5] = ACTIONS(394), - [aux_sym__logical_operator_token6] = ACTIONS(394), - [aux_sym_input_expression_token2] = ACTIONS(394), - [anon_sym_PLUS] = ACTIONS(394), - [anon_sym_DASH] = ACTIONS(394), - [anon_sym_STAR] = ACTIONS(394), - [anon_sym_LT] = ACTIONS(392), - [anon_sym_LT_EQ] = ACTIONS(394), - [anon_sym_LT_GT] = ACTIONS(394), - [anon_sym_EQ] = ACTIONS(394), - [anon_sym_GT] = ACTIONS(392), - [anon_sym_GT_EQ] = ACTIONS(394), - [aux_sym__comparison_operator_token1] = ACTIONS(394), - [aux_sym__comparison_operator_token2] = ACTIONS(394), - [aux_sym__comparison_operator_token3] = ACTIONS(394), - [aux_sym__comparison_operator_token4] = ACTIONS(394), - [aux_sym__comparison_operator_token5] = ACTIONS(394), - [aux_sym__comparison_operator_token6] = ACTIONS(394), - [aux_sym__comparison_operator_token7] = ACTIONS(394), - [aux_sym__comparison_operator_token8] = ACTIONS(394), - [aux_sym__comparison_operator_token9] = ACTIONS(394), - [aux_sym_variable_tuning_token1] = ACTIONS(394), - [aux_sym_variable_tuning_token2] = ACTIONS(394), - [aux_sym_variable_tuning_token3] = ACTIONS(394), - [aux_sym_variable_tuning_token4] = ACTIONS(394), - [aux_sym_variable_tuning_token5] = ACTIONS(394), - [aux_sym_variable_tuning_token6] = ACTIONS(394), - [aux_sym_serialization_tuning_token1] = ACTIONS(394), - [anon_sym_COMMA] = ACTIONS(394), - [aux_sym_if_statement_token2] = ACTIONS(394), - [aux_sym_else_if_statement_token1] = ACTIONS(394), - [anon_sym_COLON] = ACTIONS(394), - [aux_sym_do_while_statement_token1] = ACTIONS(394), - [aux_sym_do_statement_token1] = ACTIONS(394), - [aux_sym_class_statement_token2] = ACTIONS(394), - [aux_sym_implements_token1] = ACTIONS(394), - [aux_sym_use_widget_pool_token1] = ACTIONS(394), - [aux_sym_abstract_token1] = ACTIONS(394), - [aux_sym_final_token1] = ACTIONS(394), - [aux_sym_on_error_phrase_token1] = ACTIONS(394), - [aux_sym_where_clause_token1] = ACTIONS(394), - [aux_sym_query_tuning_token1] = ACTIONS(394), - [aux_sym_query_tuning_token2] = ACTIONS(394), - [aux_sym_query_tuning_token3] = ACTIONS(394), - [aux_sym_query_tuning_token4] = ACTIONS(394), - [aux_sym_query_tuning_token5] = ACTIONS(394), - [aux_sym_query_tuning_token6] = ACTIONS(394), - [aux_sym_sort_clause_token1] = ACTIONS(394), - [aux_sym_sort_clause_token2] = ACTIONS(394), - [aux_sym_of_token1] = ACTIONS(394), - [aux_sym__using_first_token1] = ACTIONS(394), - [aux_sym_widget_field_token1] = ACTIONS(392), - [aux_sym_on_statement_token1] = ACTIONS(394), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(590), + [aux_sym_can_find_expression_repeat2] = STATE(1653), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(216), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), }, [279] = { [sym_comment] = STATE(279), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(279), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(396), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(398), - [anon_sym_LPAREN] = ACTIONS(398), - [anon_sym_RPAREN] = ACTIONS(398), - [aux_sym__logical_operator_token1] = ACTIONS(398), - [aux_sym__logical_operator_token2] = ACTIONS(398), - [aux_sym__logical_operator_token3] = ACTIONS(398), - [aux_sym__logical_operator_token4] = ACTIONS(398), - [aux_sym__logical_operator_token5] = ACTIONS(398), - [aux_sym__logical_operator_token6] = ACTIONS(398), - [aux_sym_input_expression_token2] = ACTIONS(398), - [anon_sym_PLUS] = ACTIONS(398), - [anon_sym_DASH] = ACTIONS(398), - [anon_sym_STAR] = ACTIONS(398), - [anon_sym_LT] = ACTIONS(396), - [anon_sym_LT_EQ] = ACTIONS(398), - [anon_sym_LT_GT] = ACTIONS(398), - [anon_sym_EQ] = ACTIONS(398), - [anon_sym_GT] = ACTIONS(396), - [anon_sym_GT_EQ] = ACTIONS(398), - [aux_sym__comparison_operator_token1] = ACTIONS(398), - [aux_sym__comparison_operator_token2] = ACTIONS(398), - [aux_sym__comparison_operator_token3] = ACTIONS(398), - [aux_sym__comparison_operator_token4] = ACTIONS(398), - [aux_sym__comparison_operator_token5] = ACTIONS(398), - [aux_sym__comparison_operator_token6] = ACTIONS(398), - [aux_sym__comparison_operator_token7] = ACTIONS(398), - [aux_sym__comparison_operator_token8] = ACTIONS(398), - [aux_sym__comparison_operator_token9] = ACTIONS(398), - [aux_sym_variable_tuning_token1] = ACTIONS(398), - [aux_sym_variable_tuning_token2] = ACTIONS(398), - [aux_sym_variable_tuning_token3] = ACTIONS(398), - [aux_sym_variable_tuning_token4] = ACTIONS(398), - [aux_sym_variable_tuning_token5] = ACTIONS(398), - [aux_sym_variable_tuning_token6] = ACTIONS(398), - [aux_sym_serialization_tuning_token1] = ACTIONS(398), - [anon_sym_COMMA] = ACTIONS(398), - [aux_sym_if_statement_token2] = ACTIONS(398), - [aux_sym_else_if_statement_token1] = ACTIONS(398), - [anon_sym_COLON] = ACTIONS(398), - [aux_sym_do_while_statement_token1] = ACTIONS(398), - [aux_sym_do_statement_token1] = ACTIONS(398), - [aux_sym_class_statement_token2] = ACTIONS(398), - [aux_sym_implements_token1] = ACTIONS(398), - [aux_sym_use_widget_pool_token1] = ACTIONS(398), - [aux_sym_abstract_token1] = ACTIONS(398), - [aux_sym_final_token1] = ACTIONS(398), - [aux_sym_on_error_phrase_token1] = ACTIONS(398), - [aux_sym_where_clause_token1] = ACTIONS(398), - [aux_sym_query_tuning_token1] = ACTIONS(398), - [aux_sym_query_tuning_token2] = ACTIONS(398), - [aux_sym_query_tuning_token3] = ACTIONS(398), - [aux_sym_query_tuning_token4] = ACTIONS(398), - [aux_sym_query_tuning_token5] = ACTIONS(398), - [aux_sym_query_tuning_token6] = ACTIONS(398), - [aux_sym_sort_clause_token1] = ACTIONS(398), - [aux_sym_sort_clause_token2] = ACTIONS(398), - [aux_sym_of_token1] = ACTIONS(398), - [aux_sym__using_first_token1] = ACTIONS(398), - [aux_sym_widget_field_token1] = ACTIONS(396), - [aux_sym_on_statement_token1] = ACTIONS(398), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(588), + [aux_sym_can_find_expression_repeat2] = STATE(1661), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(214), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), }, [280] = { [sym_comment] = STATE(280), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), [sym_include] = STATE(280), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(400), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(402), - [anon_sym_LPAREN] = ACTIONS(402), - [anon_sym_RPAREN] = ACTIONS(402), - [aux_sym__logical_operator_token1] = ACTIONS(402), - [aux_sym__logical_operator_token2] = ACTIONS(402), - [aux_sym__logical_operator_token3] = ACTIONS(402), - [aux_sym__logical_operator_token4] = ACTIONS(402), - [aux_sym__logical_operator_token5] = ACTIONS(402), - [aux_sym__logical_operator_token6] = ACTIONS(402), - [aux_sym_input_expression_token2] = ACTIONS(402), - [anon_sym_PLUS] = ACTIONS(402), - [anon_sym_DASH] = ACTIONS(402), - [anon_sym_STAR] = ACTIONS(402), - [anon_sym_LT] = ACTIONS(400), - [anon_sym_LT_EQ] = ACTIONS(402), - [anon_sym_LT_GT] = ACTIONS(402), - [anon_sym_EQ] = ACTIONS(402), - [anon_sym_GT] = ACTIONS(400), - [anon_sym_GT_EQ] = ACTIONS(402), - [aux_sym__comparison_operator_token1] = ACTIONS(402), - [aux_sym__comparison_operator_token2] = ACTIONS(402), - [aux_sym__comparison_operator_token3] = ACTIONS(402), - [aux_sym__comparison_operator_token4] = ACTIONS(402), - [aux_sym__comparison_operator_token5] = ACTIONS(402), - [aux_sym__comparison_operator_token6] = ACTIONS(402), - [aux_sym__comparison_operator_token7] = ACTIONS(402), - [aux_sym__comparison_operator_token8] = ACTIONS(402), - [aux_sym__comparison_operator_token9] = ACTIONS(402), - [aux_sym_variable_tuning_token1] = ACTIONS(402), - [aux_sym_variable_tuning_token2] = ACTIONS(402), - [aux_sym_variable_tuning_token3] = ACTIONS(402), - [aux_sym_variable_tuning_token4] = ACTIONS(402), - [aux_sym_variable_tuning_token5] = ACTIONS(402), - [aux_sym_variable_tuning_token6] = ACTIONS(402), - [aux_sym_serialization_tuning_token1] = ACTIONS(402), - [anon_sym_COMMA] = ACTIONS(402), - [aux_sym_if_statement_token2] = ACTIONS(402), - [aux_sym_else_if_statement_token1] = ACTIONS(402), - [anon_sym_COLON] = ACTIONS(402), - [aux_sym_do_while_statement_token1] = ACTIONS(402), - [aux_sym_do_statement_token1] = ACTIONS(402), - [aux_sym_class_statement_token2] = ACTIONS(402), - [aux_sym_implements_token1] = ACTIONS(402), - [aux_sym_use_widget_pool_token1] = ACTIONS(402), - [aux_sym_abstract_token1] = ACTIONS(402), - [aux_sym_final_token1] = ACTIONS(402), - [aux_sym_on_error_phrase_token1] = ACTIONS(402), - [aux_sym_where_clause_token1] = ACTIONS(402), - [aux_sym_query_tuning_token1] = ACTIONS(402), - [aux_sym_query_tuning_token2] = ACTIONS(402), - [aux_sym_query_tuning_token3] = ACTIONS(402), - [aux_sym_query_tuning_token4] = ACTIONS(402), - [aux_sym_query_tuning_token5] = ACTIONS(402), - [aux_sym_query_tuning_token6] = ACTIONS(402), - [aux_sym_sort_clause_token1] = ACTIONS(402), - [aux_sym_sort_clause_token2] = ACTIONS(402), - [aux_sym_of_token1] = ACTIONS(402), - [aux_sym__using_first_token1] = ACTIONS(402), - [aux_sym_widget_field_token1] = ACTIONS(400), - [aux_sym_on_statement_token1] = ACTIONS(402), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(586), + [aux_sym_can_find_expression_repeat2] = STATE(1660), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(218), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), }, [281] = { [sym_comment] = STATE(281), [sym_include] = STATE(281), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(404), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(406), - [anon_sym_LPAREN] = ACTIONS(406), - [anon_sym_RPAREN] = ACTIONS(406), - [aux_sym__logical_operator_token1] = ACTIONS(406), - [aux_sym__logical_operator_token2] = ACTIONS(406), - [aux_sym__logical_operator_token3] = ACTIONS(406), - [aux_sym__logical_operator_token4] = ACTIONS(406), - [aux_sym__logical_operator_token5] = ACTIONS(406), - [aux_sym__logical_operator_token6] = ACTIONS(406), - [aux_sym_input_expression_token2] = ACTIONS(406), - [anon_sym_PLUS] = ACTIONS(406), - [anon_sym_DASH] = ACTIONS(406), - [anon_sym_STAR] = ACTIONS(406), - [anon_sym_LT] = ACTIONS(404), - [anon_sym_LT_EQ] = ACTIONS(406), - [anon_sym_LT_GT] = ACTIONS(406), - [anon_sym_EQ] = ACTIONS(406), - [anon_sym_GT] = ACTIONS(404), - [anon_sym_GT_EQ] = ACTIONS(406), - [aux_sym__comparison_operator_token1] = ACTIONS(406), - [aux_sym__comparison_operator_token2] = ACTIONS(406), - [aux_sym__comparison_operator_token3] = ACTIONS(406), - [aux_sym__comparison_operator_token4] = ACTIONS(406), - [aux_sym__comparison_operator_token5] = ACTIONS(406), - [aux_sym__comparison_operator_token6] = ACTIONS(406), - [aux_sym__comparison_operator_token7] = ACTIONS(406), - [aux_sym__comparison_operator_token8] = ACTIONS(406), - [aux_sym__comparison_operator_token9] = ACTIONS(406), - [aux_sym_variable_tuning_token1] = ACTIONS(406), - [aux_sym_variable_tuning_token2] = ACTIONS(406), - [aux_sym_variable_tuning_token3] = ACTIONS(406), - [aux_sym_variable_tuning_token4] = ACTIONS(406), - [aux_sym_variable_tuning_token5] = ACTIONS(406), - [aux_sym_variable_tuning_token6] = ACTIONS(406), - [aux_sym_serialization_tuning_token1] = ACTIONS(406), - [anon_sym_COMMA] = ACTIONS(406), - [aux_sym_if_statement_token2] = ACTIONS(406), - [aux_sym_else_if_statement_token1] = ACTIONS(406), - [anon_sym_COLON] = ACTIONS(406), - [aux_sym_do_while_statement_token1] = ACTIONS(406), - [aux_sym_do_statement_token1] = ACTIONS(406), - [aux_sym_class_statement_token2] = ACTIONS(406), - [aux_sym_implements_token1] = ACTIONS(406), - [aux_sym_use_widget_pool_token1] = ACTIONS(406), - [aux_sym_abstract_token1] = ACTIONS(406), - [aux_sym_final_token1] = ACTIONS(406), - [aux_sym_on_error_phrase_token1] = ACTIONS(406), - [aux_sym_where_clause_token1] = ACTIONS(406), - [aux_sym_query_tuning_token1] = ACTIONS(406), - [aux_sym_query_tuning_token2] = ACTIONS(406), - [aux_sym_query_tuning_token3] = ACTIONS(406), - [aux_sym_query_tuning_token4] = ACTIONS(406), - [aux_sym_query_tuning_token5] = ACTIONS(406), - [aux_sym_query_tuning_token6] = ACTIONS(406), - [aux_sym_sort_clause_token1] = ACTIONS(406), - [aux_sym_sort_clause_token2] = ACTIONS(406), - [aux_sym_of_token1] = ACTIONS(406), - [aux_sym__using_first_token1] = ACTIONS(406), - [aux_sym_widget_field_token1] = ACTIONS(404), - [aux_sym_on_statement_token1] = ACTIONS(406), + [sym_assignment] = STATE(3776), + [sym_variable_definition] = STATE(1412), + [sym_variable_assignment] = STATE(1412), + [sym_buffer_definition] = STATE(1412), + [sym_query_definition] = STATE(1412), + [sym_function_call_statement] = STATE(1412), + [sym_function_call] = STATE(3774), + [sym_if_statement] = STATE(1412), + [sym_label] = STATE(1416), + [sym__loop_statement] = STATE(1412), + [sym_repeat_statement] = STATE(1425), + [sym_do_while_statement] = STATE(1425), + [sym_procedure_statement] = STATE(1412), + [sym_procedure_parameter_definition] = STATE(1412), + [sym_function_statement] = STATE(1412), + [sym_return_statement] = STATE(1412), + [sym_interface_statement] = STATE(1412), + [sym_class_statement] = STATE(1412), + [sym_stream_definition] = STATE(1412), + [sym_input_close_statement] = STATE(1412), + [sym_output_close_statement] = STATE(1412), + [sym__stream_statement] = STATE(1412), + [sym_input_stream_statement] = STATE(1428), + [sym_output_stream_statement] = STATE(1428), + [sym_do_block] = STATE(1412), + [sym_case_statement] = STATE(1412), + [sym_for_statement] = STATE(1412), + [sym_find_statement] = STATE(1412), + [sym_abl_statement] = STATE(1412), + [sym_assign_statement] = STATE(1412), + [sym_catch_statement] = STATE(1412), + [sym_finally_statement] = STATE(1412), + [sym_accumulate_statement] = STATE(1412), + [sym_undo_statement] = STATE(1412), + [sym_error_scope_statement] = STATE(1412), + [sym_temp_table_definition] = STATE(1412), + [sym_on_statement] = STATE(1412), + [sym__statement] = STATE(1466), + [aux_sym_source_code_repeat1] = STATE(282), + [ts_builtin_sym_end] = ACTIONS(256), + [sym_identifier] = ACTIONS(11), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym_input_expression_token1] = ACTIONS(13), + [aux_sym_variable_definition_token1] = ACTIONS(15), + [aux_sym_variable_definition_token2] = ACTIONS(17), + [aux_sym_buffer_definition_token2] = ACTIONS(19), + [aux_sym_argument_mode_token1] = ACTIONS(21), + [aux_sym_if_statement_token1] = ACTIONS(23), + [aux_sym_repeat_statement_token1] = ACTIONS(25), + [aux_sym_do_while_statement_token1] = ACTIONS(27), + [aux_sym__procedure_terminator_token1] = ACTIONS(29), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(31), + [aux_sym__function_terminator_token1] = ACTIONS(33), + [aux_sym_interface_statement_token1] = ACTIONS(35), + [aux_sym_class_statement_token1] = ACTIONS(37), + [aux_sym_on_error_phrase_token1] = ACTIONS(39), + [aux_sym_on_error_phrase_token3] = ACTIONS(41), + [aux_sym__case_terminator_token1] = ACTIONS(43), + [aux_sym_find_statement_token1] = ACTIONS(45), + [aux_sym_assign_statement_token1] = ACTIONS(47), + [aux_sym_catch_statement_token1] = ACTIONS(49), + [aux_sym_finally_statement_token1] = ACTIONS(51), + [aux_sym_accumulate_statement_token1] = ACTIONS(53), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(55), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(55), }, [282] = { [sym_comment] = STATE(282), [sym_include] = STATE(282), - [anon_sym_SLASH_SLASH] = ACTIONS(373), - [anon_sym_SLASH_STAR] = ACTIONS(375), - [anon_sym_SLASH] = ACTIONS(408), - [anon_sym_LBRACE] = ACTIONS(379), - [sym__terminator] = ACTIONS(410), - [anon_sym_LPAREN] = ACTIONS(410), - [anon_sym_RPAREN] = ACTIONS(410), - [aux_sym__logical_operator_token1] = ACTIONS(410), - [aux_sym__logical_operator_token2] = ACTIONS(410), - [aux_sym__logical_operator_token3] = ACTIONS(410), - [aux_sym__logical_operator_token4] = ACTIONS(410), - [aux_sym__logical_operator_token5] = ACTIONS(410), - [aux_sym__logical_operator_token6] = ACTIONS(410), - [aux_sym_input_expression_token2] = ACTIONS(410), - [anon_sym_PLUS] = ACTIONS(410), - [anon_sym_DASH] = ACTIONS(410), - [anon_sym_STAR] = ACTIONS(410), - [anon_sym_LT] = ACTIONS(408), - [anon_sym_LT_EQ] = ACTIONS(410), - [anon_sym_LT_GT] = ACTIONS(410), - [anon_sym_EQ] = ACTIONS(410), - [anon_sym_GT] = ACTIONS(408), - [anon_sym_GT_EQ] = ACTIONS(410), - [aux_sym__comparison_operator_token1] = ACTIONS(410), - [aux_sym__comparison_operator_token2] = ACTIONS(410), - [aux_sym__comparison_operator_token3] = ACTIONS(410), - [aux_sym__comparison_operator_token4] = ACTIONS(410), - [aux_sym__comparison_operator_token5] = ACTIONS(410), - [aux_sym__comparison_operator_token6] = ACTIONS(410), - [aux_sym__comparison_operator_token7] = ACTIONS(410), - [aux_sym__comparison_operator_token8] = ACTIONS(410), - [aux_sym__comparison_operator_token9] = ACTIONS(410), - [aux_sym_variable_tuning_token1] = ACTIONS(410), - [aux_sym_variable_tuning_token2] = ACTIONS(410), - [aux_sym_variable_tuning_token3] = ACTIONS(410), - [aux_sym_variable_tuning_token4] = ACTIONS(410), - [aux_sym_variable_tuning_token5] = ACTIONS(410), - [aux_sym_variable_tuning_token6] = ACTIONS(410), - [aux_sym_serialization_tuning_token1] = ACTIONS(410), - [anon_sym_COMMA] = ACTIONS(410), - [aux_sym_if_statement_token2] = ACTIONS(410), - [aux_sym_else_if_statement_token1] = ACTIONS(410), - [anon_sym_COLON] = ACTIONS(410), - [aux_sym_do_while_statement_token1] = ACTIONS(410), - [aux_sym_do_statement_token1] = ACTIONS(410), - [aux_sym_class_statement_token2] = ACTIONS(410), - [aux_sym_implements_token1] = ACTIONS(410), - [aux_sym_use_widget_pool_token1] = ACTIONS(410), - [aux_sym_abstract_token1] = ACTIONS(410), - [aux_sym_final_token1] = ACTIONS(410), - [aux_sym_on_error_phrase_token1] = ACTIONS(410), - [aux_sym_where_clause_token1] = ACTIONS(410), - [aux_sym_query_tuning_token1] = ACTIONS(410), - [aux_sym_query_tuning_token2] = ACTIONS(410), - [aux_sym_query_tuning_token3] = ACTIONS(410), - [aux_sym_query_tuning_token4] = ACTIONS(410), - [aux_sym_query_tuning_token5] = ACTIONS(410), - [aux_sym_query_tuning_token6] = ACTIONS(410), - [aux_sym_sort_clause_token1] = ACTIONS(410), - [aux_sym_sort_clause_token2] = ACTIONS(410), - [aux_sym_of_token1] = ACTIONS(410), - [aux_sym__using_first_token1] = ACTIONS(410), - [aux_sym_widget_field_token1] = ACTIONS(408), - [aux_sym_on_statement_token1] = ACTIONS(410), + [sym_assignment] = STATE(3776), + [sym_variable_definition] = STATE(1412), + [sym_variable_assignment] = STATE(1412), + [sym_buffer_definition] = STATE(1412), + [sym_query_definition] = STATE(1412), + [sym_function_call_statement] = STATE(1412), + [sym_function_call] = STATE(3774), + [sym_if_statement] = STATE(1412), + [sym_label] = STATE(1416), + [sym__loop_statement] = STATE(1412), + [sym_repeat_statement] = STATE(1425), + [sym_do_while_statement] = STATE(1425), + [sym_procedure_statement] = STATE(1412), + [sym_procedure_parameter_definition] = STATE(1412), + [sym_function_statement] = STATE(1412), + [sym_return_statement] = STATE(1412), + [sym_interface_statement] = STATE(1412), + [sym_class_statement] = STATE(1412), + [sym_stream_definition] = STATE(1412), + [sym_input_close_statement] = STATE(1412), + [sym_output_close_statement] = STATE(1412), + [sym__stream_statement] = STATE(1412), + [sym_input_stream_statement] = STATE(1428), + [sym_output_stream_statement] = STATE(1428), + [sym_do_block] = STATE(1412), + [sym_case_statement] = STATE(1412), + [sym_for_statement] = STATE(1412), + [sym_find_statement] = STATE(1412), + [sym_abl_statement] = STATE(1412), + [sym_assign_statement] = STATE(1412), + [sym_catch_statement] = STATE(1412), + [sym_finally_statement] = STATE(1412), + [sym_accumulate_statement] = STATE(1412), + [sym_undo_statement] = STATE(1412), + [sym_error_scope_statement] = STATE(1412), + [sym_temp_table_definition] = STATE(1412), + [sym_on_statement] = STATE(1412), + [sym__statement] = STATE(1466), + [aux_sym_source_code_repeat1] = STATE(282), + [ts_builtin_sym_end] = ACTIONS(258), + [sym_identifier] = ACTIONS(260), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym_input_expression_token1] = ACTIONS(263), + [aux_sym_variable_definition_token1] = ACTIONS(266), + [aux_sym_variable_definition_token2] = ACTIONS(269), + [aux_sym_buffer_definition_token2] = ACTIONS(272), + [aux_sym_argument_mode_token1] = ACTIONS(275), + [aux_sym_if_statement_token1] = ACTIONS(278), + [aux_sym_repeat_statement_token1] = ACTIONS(281), + [aux_sym_do_while_statement_token1] = ACTIONS(284), + [aux_sym__procedure_terminator_token1] = ACTIONS(287), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(290), + [aux_sym__function_terminator_token1] = ACTIONS(293), + [aux_sym_interface_statement_token1] = ACTIONS(296), + [aux_sym_class_statement_token1] = ACTIONS(299), + [aux_sym_on_error_phrase_token1] = ACTIONS(302), + [aux_sym_on_error_phrase_token3] = ACTIONS(305), + [aux_sym__case_terminator_token1] = ACTIONS(308), + [aux_sym_find_statement_token1] = ACTIONS(311), + [aux_sym_assign_statement_token1] = ACTIONS(314), + [aux_sym_catch_statement_token1] = ACTIONS(317), + [aux_sym_finally_statement_token1] = ACTIONS(320), + [aux_sym_accumulate_statement_token1] = ACTIONS(323), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(326), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(326), + }, + [283] = { + [sym_comment] = STATE(283), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(283), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(596), + [aux_sym_can_find_expression_repeat2] = STATE(1669), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(222), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [284] = { + [sym_comment] = STATE(284), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(284), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(595), + [aux_sym_can_find_expression_repeat2] = STATE(1671), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(220), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [285] = { + [sym_comment] = STATE(285), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(285), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(592), + [aux_sym_can_find_expression_repeat2] = STATE(1664), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(224), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [286] = { + [sym_comment] = STATE(286), + [sym_include] = STATE(286), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(290), + [sym_identifier] = ACTIONS(76), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(329), + [aux_sym_input_expression_token1] = ACTIONS(80), + [aux_sym_variable_definition_token1] = ACTIONS(82), + [aux_sym_variable_definition_token2] = ACTIONS(84), + [aux_sym_buffer_definition_token2] = ACTIONS(86), + [aux_sym_argument_mode_token1] = ACTIONS(88), + [aux_sym_if_statement_token1] = ACTIONS(90), + [aux_sym_repeat_statement_token1] = ACTIONS(92), + [aux_sym_do_while_statement_token1] = ACTIONS(94), + [aux_sym__procedure_terminator_token1] = ACTIONS(96), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(98), + [aux_sym__function_terminator_token1] = ACTIONS(100), + [aux_sym_interface_statement_token1] = ACTIONS(102), + [aux_sym_class_statement_token1] = ACTIONS(104), + [aux_sym_on_error_phrase_token1] = ACTIONS(106), + [aux_sym_on_error_phrase_token3] = ACTIONS(108), + [aux_sym__case_terminator_token1] = ACTIONS(110), + [aux_sym_find_statement_token1] = ACTIONS(112), + [aux_sym_assign_statement_token1] = ACTIONS(114), + [aux_sym_catch_statement_token1] = ACTIONS(116), + [aux_sym_finally_statement_token1] = ACTIONS(118), + [aux_sym_accumulate_statement_token1] = ACTIONS(120), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(122), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(122), + }, + [287] = { + [sym_comment] = STATE(287), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(287), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(585), + [aux_sym_can_find_expression_repeat2] = STATE(1674), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(184), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [288] = { + [sym_comment] = STATE(288), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(288), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(593), + [aux_sym_can_find_expression_repeat2] = STATE(1684), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(232), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [289] = { + [sym_comment] = STATE(289), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(289), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(594), + [aux_sym_can_find_expression_repeat2] = STATE(1658), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(226), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [290] = { + [sym_comment] = STATE(290), + [sym_include] = STATE(290), + [sym_assignment] = STATE(3748), + [sym_variable_definition] = STATE(1387), + [sym_variable_assignment] = STATE(1387), + [sym_buffer_definition] = STATE(1387), + [sym_query_definition] = STATE(1387), + [sym_function_call_statement] = STATE(1387), + [sym_function_call] = STATE(3730), + [sym_if_statement] = STATE(1387), + [sym_label] = STATE(1388), + [sym__loop_statement] = STATE(1387), + [sym_repeat_statement] = STATE(1389), + [sym_do_while_statement] = STATE(1389), + [sym_procedure_statement] = STATE(1387), + [sym_procedure_parameter_definition] = STATE(1387), + [sym_function_statement] = STATE(1387), + [sym_return_statement] = STATE(1387), + [sym_interface_statement] = STATE(1387), + [sym_class_statement] = STATE(1387), + [sym_stream_definition] = STATE(1387), + [sym_input_close_statement] = STATE(1387), + [sym_output_close_statement] = STATE(1387), + [sym__stream_statement] = STATE(1387), + [sym_input_stream_statement] = STATE(1390), + [sym_output_stream_statement] = STATE(1390), + [sym_do_block] = STATE(1387), + [sym_case_statement] = STATE(1387), + [sym_for_statement] = STATE(1387), + [sym_find_statement] = STATE(1387), + [sym_abl_statement] = STATE(1387), + [sym_assign_statement] = STATE(1387), + [sym_catch_statement] = STATE(1387), + [sym_finally_statement] = STATE(1387), + [sym_accumulate_statement] = STATE(1387), + [sym_undo_statement] = STATE(1387), + [sym_error_scope_statement] = STATE(1387), + [sym_temp_table_definition] = STATE(1387), + [sym_on_statement] = STATE(1387), + [sym__statement] = STATE(1391), + [aux_sym_source_code_repeat1] = STATE(290), + [sym_identifier] = ACTIONS(331), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(7), + [aux_sym__block_terminator_token1] = ACTIONS(334), + [aux_sym_input_expression_token1] = ACTIONS(336), + [aux_sym_variable_definition_token1] = ACTIONS(339), + [aux_sym_variable_definition_token2] = ACTIONS(342), + [aux_sym_buffer_definition_token2] = ACTIONS(345), + [aux_sym_argument_mode_token1] = ACTIONS(348), + [aux_sym_if_statement_token1] = ACTIONS(351), + [aux_sym_repeat_statement_token1] = ACTIONS(354), + [aux_sym_do_while_statement_token1] = ACTIONS(357), + [aux_sym__procedure_terminator_token1] = ACTIONS(360), + [aux_sym_procedure_parameter_definition_token1] = ACTIONS(363), + [aux_sym__function_terminator_token1] = ACTIONS(366), + [aux_sym_interface_statement_token1] = ACTIONS(369), + [aux_sym_class_statement_token1] = ACTIONS(372), + [aux_sym_on_error_phrase_token1] = ACTIONS(375), + [aux_sym_on_error_phrase_token3] = ACTIONS(378), + [aux_sym__case_terminator_token1] = ACTIONS(381), + [aux_sym_find_statement_token1] = ACTIONS(384), + [aux_sym_assign_statement_token1] = ACTIONS(387), + [aux_sym_catch_statement_token1] = ACTIONS(390), + [aux_sym_finally_statement_token1] = ACTIONS(393), + [aux_sym_accumulate_statement_token1] = ACTIONS(396), + [anon_sym_ROUTINE_DASHLEVEL] = ACTIONS(399), + [anon_sym_BLOCK_DASHLEVEL] = ACTIONS(399), + }, + [291] = { + [sym_comment] = STATE(291), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(291), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(587), + [aux_sym_can_find_expression_repeat2] = STATE(1655), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(230), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [292] = { + [sym_comment] = STATE(292), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(292), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(589), + [aux_sym_can_find_expression_repeat2] = STATE(1676), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(228), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [293] = { + [sym_comment] = STATE(293), + [sym_constant] = STATE(308), + [sym_qualified_name] = STATE(308), + [sym_boolean_literal] = STATE(308), + [sym__decimal_literal] = STATE(301), + [sym_number_literal] = STATE(308), + [sym__string_literal] = STATE(308), + [sym_double_quoted_string] = STATE(296), + [sym_single_quoted_string] = STATE(296), + [sym_parenthesized_expression] = STATE(308), + [sym_logical_expression] = STATE(305), + [sym_unary_expression] = STATE(308), + [sym_ambiguous_expression] = STATE(308), + [sym_current_changed_expression] = STATE(308), + [sym_locked_expression] = STATE(308), + [sym_input_expression] = STATE(308), + [sym_additive_expression] = STATE(305), + [sym_multiplicative_expression] = STATE(305), + [sym_comparison_expression] = STATE(305), + [sym__binary_expression] = STATE(308), + [sym_include] = STATE(293), + [sym_function_call] = STATE(308), + [sym_ternary_expression] = STATE(308), + [sym_new_expression] = STATE(308), + [sym_object_access] = STATE(308), + [sym_where_clause] = STATE(1907), + [sym_query_tuning] = STATE(1907), + [sym_can_find_expression] = STATE(308), + [sym_of] = STATE(1907), + [sym__using_first] = STATE(1743), + [sym_accumulate_expression] = STATE(308), + [sym_available_expression] = STATE(308), + [sym__expression] = STATE(591), + [aux_sym_can_find_expression_repeat2] = STATE(1682), + [sym_identifier] = ACTIONS(126), + [anon_sym_SLASH_SLASH] = ACTIONS(3), + [anon_sym_SLASH_STAR] = ACTIONS(5), + [anon_sym_LBRACE] = ACTIONS(128), + [sym_null_expression] = ACTIONS(130), + [aux_sym_boolean_literal_token1] = ACTIONS(132), + [aux_sym_boolean_literal_token2] = ACTIONS(132), + [aux_sym_boolean_literal_token3] = ACTIONS(132), + [aux_sym_boolean_literal_token4] = ACTIONS(132), + [sym__integer_literal] = ACTIONS(134), + [anon_sym_DQUOTE] = ACTIONS(136), + [anon_sym_SQUOTE] = ACTIONS(138), + [anon_sym_LPAREN] = ACTIONS(140), + [anon_sym_RPAREN] = ACTIONS(234), + [aux_sym_unary_expression_token1] = ACTIONS(144), + [aux_sym_unary_expression_token2] = ACTIONS(186), + [aux_sym_ambiguous_expression_token1] = ACTIONS(188), + [aux_sym_current_changed_expression_token1] = ACTIONS(190), + [aux_sym_locked_expression_token1] = ACTIONS(192), + [aux_sym_input_expression_token1] = ACTIONS(194), + [aux_sym_scope_tuning_token1] = ACTIONS(196), + [aux_sym_if_statement_token1] = ACTIONS(198), + [aux_sym_where_clause_token1] = ACTIONS(200), + [aux_sym_query_tuning_token1] = ACTIONS(202), + [aux_sym_query_tuning_token2] = ACTIONS(202), + [aux_sym_query_tuning_token3] = ACTIONS(202), + [aux_sym_query_tuning_token4] = ACTIONS(202), + [aux_sym_query_tuning_token5] = ACTIONS(202), + [aux_sym_query_tuning_token6] = ACTIONS(204), + [aux_sym_can_find_expression_token1] = ACTIONS(162), + [aux_sym_of_token1] = ACTIONS(206), + [aux_sym__using_first_token1] = ACTIONS(208), + [aux_sym_accumulate_expression_token1] = ACTIONS(210), + [aux_sym_available_expression_token1] = ACTIONS(168), + [aux_sym_available_expression_token2] = ACTIONS(168), + }, + [294] = { + [sym_comment] = STATE(294), + [sym_include] = STATE(294), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(402), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(404), + [anon_sym_LPAREN] = ACTIONS(404), + [anon_sym_RPAREN] = ACTIONS(404), + [aux_sym__logical_operator_token1] = ACTIONS(404), + [aux_sym__logical_operator_token2] = ACTIONS(404), + [aux_sym__logical_operator_token3] = ACTIONS(404), + [aux_sym__logical_operator_token4] = ACTIONS(404), + [aux_sym__logical_operator_token5] = ACTIONS(404), + [aux_sym__logical_operator_token6] = ACTIONS(404), + [anon_sym_PLUS] = ACTIONS(404), + [anon_sym_DASH] = ACTIONS(404), + [anon_sym_STAR] = ACTIONS(404), + [anon_sym_LT] = ACTIONS(402), + [anon_sym_LT_EQ] = ACTIONS(404), + [anon_sym_LT_GT] = ACTIONS(404), + [anon_sym_EQ] = ACTIONS(404), + [anon_sym_GT] = ACTIONS(402), + [anon_sym_GT_EQ] = ACTIONS(404), + [aux_sym__comparison_operator_token1] = ACTIONS(404), + [aux_sym__comparison_operator_token2] = ACTIONS(404), + [aux_sym__comparison_operator_token3] = ACTIONS(404), + [aux_sym__comparison_operator_token4] = ACTIONS(404), + [aux_sym__comparison_operator_token5] = ACTIONS(404), + [aux_sym__comparison_operator_token6] = ACTIONS(404), + [aux_sym__comparison_operator_token7] = ACTIONS(404), + [aux_sym__comparison_operator_token8] = ACTIONS(404), + [aux_sym__comparison_operator_token9] = ACTIONS(404), + [aux_sym_variable_tuning_token1] = ACTIONS(404), + [aux_sym_variable_tuning_token2] = ACTIONS(404), + [aux_sym_variable_tuning_token3] = ACTIONS(404), + [aux_sym_variable_tuning_token4] = ACTIONS(404), + [aux_sym_variable_tuning_token5] = ACTIONS(404), + [aux_sym_variable_tuning_token6] = ACTIONS(404), + [aux_sym_serialization_tuning_token1] = ACTIONS(404), + [anon_sym_COMMA] = ACTIONS(404), + [aux_sym_if_statement_token2] = ACTIONS(404), + [aux_sym_else_if_statement_token1] = ACTIONS(404), + [anon_sym_COLON] = ACTIONS(404), + [aux_sym_property_tuning_token1] = ACTIONS(404), + [aux_sym_property_definition_token2] = ACTIONS(404), + [aux_sym_inherits_token1] = ACTIONS(404), + [aux_sym_implements_token1] = ACTIONS(404), + [aux_sym_use_widget_pool_token1] = ACTIONS(404), + [aux_sym_final_token1] = ACTIONS(404), + [aux_sym_output_stream_statement_token1] = ACTIONS(404), + [aux_sym_on_error_phrase_token1] = ACTIONS(404), + [aux_sym_stop_after_phrase_token1] = ACTIONS(404), + [aux_sym_do_tuning_token1] = ACTIONS(404), + [anon_sym_BY] = ACTIONS(404), + [aux_sym_where_clause_token1] = ACTIONS(404), + [aux_sym_query_tuning_token1] = ACTIONS(404), + [aux_sym_query_tuning_token2] = ACTIONS(404), + [aux_sym_query_tuning_token3] = ACTIONS(404), + [aux_sym_query_tuning_token4] = ACTIONS(404), + [aux_sym_query_tuning_token5] = ACTIONS(404), + [aux_sym_query_tuning_token6] = ACTIONS(404), + [aux_sym_of_token1] = ACTIONS(404), + [aux_sym__using_first_token1] = ACTIONS(404), + [aux_sym_field_definition_token1] = ACTIONS(404), + [aux_sym_index_definition_token1] = ACTIONS(404), + [aux_sym_on_statement_token1] = ACTIONS(404), + }, + [295] = { + [sym_comment] = STATE(295), + [sym_include] = STATE(295), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(406), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(408), + [anon_sym_LPAREN] = ACTIONS(408), + [anon_sym_RPAREN] = ACTIONS(408), + [aux_sym__logical_operator_token1] = ACTIONS(408), + [aux_sym__logical_operator_token2] = ACTIONS(408), + [aux_sym__logical_operator_token3] = ACTIONS(408), + [aux_sym__logical_operator_token4] = ACTIONS(408), + [aux_sym__logical_operator_token5] = ACTIONS(408), + [aux_sym__logical_operator_token6] = ACTIONS(408), + [anon_sym_PLUS] = ACTIONS(408), + [anon_sym_DASH] = ACTIONS(408), + [anon_sym_STAR] = ACTIONS(408), + [anon_sym_LT] = ACTIONS(406), + [anon_sym_LT_EQ] = ACTIONS(408), + [anon_sym_LT_GT] = ACTIONS(408), + [anon_sym_EQ] = ACTIONS(408), + [anon_sym_GT] = ACTIONS(406), + [anon_sym_GT_EQ] = ACTIONS(408), + [aux_sym__comparison_operator_token1] = ACTIONS(408), + [aux_sym__comparison_operator_token2] = ACTIONS(408), + [aux_sym__comparison_operator_token3] = ACTIONS(408), + [aux_sym__comparison_operator_token4] = ACTIONS(408), + [aux_sym__comparison_operator_token5] = ACTIONS(408), + [aux_sym__comparison_operator_token6] = ACTIONS(408), + [aux_sym__comparison_operator_token7] = ACTIONS(408), + [aux_sym__comparison_operator_token8] = ACTIONS(408), + [aux_sym__comparison_operator_token9] = ACTIONS(408), + [aux_sym_variable_tuning_token1] = ACTIONS(408), + [aux_sym_variable_tuning_token2] = ACTIONS(408), + [aux_sym_variable_tuning_token3] = ACTIONS(408), + [aux_sym_variable_tuning_token4] = ACTIONS(408), + [aux_sym_variable_tuning_token5] = ACTIONS(408), + [aux_sym_variable_tuning_token6] = ACTIONS(408), + [aux_sym_serialization_tuning_token1] = ACTIONS(408), + [anon_sym_COMMA] = ACTIONS(408), + [aux_sym_if_statement_token2] = ACTIONS(408), + [aux_sym_else_if_statement_token1] = ACTIONS(408), + [anon_sym_COLON] = ACTIONS(408), + [aux_sym_property_tuning_token1] = ACTIONS(408), + [aux_sym_property_definition_token2] = ACTIONS(408), + [aux_sym_inherits_token1] = ACTIONS(408), + [aux_sym_implements_token1] = ACTIONS(408), + [aux_sym_use_widget_pool_token1] = ACTIONS(408), + [aux_sym_final_token1] = ACTIONS(408), + [aux_sym_output_stream_statement_token1] = ACTIONS(408), + [aux_sym_on_error_phrase_token1] = ACTIONS(408), + [aux_sym_stop_after_phrase_token1] = ACTIONS(408), + [aux_sym_do_tuning_token1] = ACTIONS(408), + [anon_sym_BY] = ACTIONS(408), + [aux_sym_where_clause_token1] = ACTIONS(408), + [aux_sym_query_tuning_token1] = ACTIONS(408), + [aux_sym_query_tuning_token2] = ACTIONS(408), + [aux_sym_query_tuning_token3] = ACTIONS(408), + [aux_sym_query_tuning_token4] = ACTIONS(408), + [aux_sym_query_tuning_token5] = ACTIONS(408), + [aux_sym_query_tuning_token6] = ACTIONS(408), + [aux_sym_of_token1] = ACTIONS(408), + [aux_sym__using_first_token1] = ACTIONS(408), + [aux_sym_field_definition_token1] = ACTIONS(408), + [aux_sym_index_definition_token1] = ACTIONS(408), + [aux_sym_on_statement_token1] = ACTIONS(408), + }, + [296] = { + [sym_comment] = STATE(296), + [sym_include] = STATE(296), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(410), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(412), + [anon_sym_LPAREN] = ACTIONS(412), + [anon_sym_RPAREN] = ACTIONS(412), + [aux_sym__logical_operator_token1] = ACTIONS(412), + [aux_sym__logical_operator_token2] = ACTIONS(412), + [aux_sym__logical_operator_token3] = ACTIONS(412), + [aux_sym__logical_operator_token4] = ACTIONS(412), + [aux_sym__logical_operator_token5] = ACTIONS(412), + [aux_sym__logical_operator_token6] = ACTIONS(412), + [anon_sym_PLUS] = ACTIONS(412), + [anon_sym_DASH] = ACTIONS(412), + [anon_sym_STAR] = ACTIONS(412), + [anon_sym_LT] = ACTIONS(410), + [anon_sym_LT_EQ] = ACTIONS(412), + [anon_sym_LT_GT] = ACTIONS(412), + [anon_sym_EQ] = ACTIONS(412), + [anon_sym_GT] = ACTIONS(410), + [anon_sym_GT_EQ] = ACTIONS(412), + [aux_sym__comparison_operator_token1] = ACTIONS(412), + [aux_sym__comparison_operator_token2] = ACTIONS(412), + [aux_sym__comparison_operator_token3] = ACTIONS(412), + [aux_sym__comparison_operator_token4] = ACTIONS(412), + [aux_sym__comparison_operator_token5] = ACTIONS(412), + [aux_sym__comparison_operator_token6] = ACTIONS(412), + [aux_sym__comparison_operator_token7] = ACTIONS(412), + [aux_sym__comparison_operator_token8] = ACTIONS(412), + [aux_sym__comparison_operator_token9] = ACTIONS(412), + [aux_sym_variable_tuning_token1] = ACTIONS(412), + [aux_sym_variable_tuning_token2] = ACTIONS(412), + [aux_sym_variable_tuning_token3] = ACTIONS(412), + [aux_sym_variable_tuning_token4] = ACTIONS(412), + [aux_sym_variable_tuning_token5] = ACTIONS(412), + [aux_sym_variable_tuning_token6] = ACTIONS(412), + [aux_sym_serialization_tuning_token1] = ACTIONS(412), + [anon_sym_COMMA] = ACTIONS(412), + [aux_sym_if_statement_token2] = ACTIONS(412), + [aux_sym_else_if_statement_token1] = ACTIONS(412), + [anon_sym_COLON] = ACTIONS(412), + [aux_sym_property_tuning_token1] = ACTIONS(412), + [aux_sym_property_definition_token2] = ACTIONS(412), + [aux_sym_inherits_token1] = ACTIONS(412), + [aux_sym_implements_token1] = ACTIONS(412), + [aux_sym_use_widget_pool_token1] = ACTIONS(412), + [aux_sym_final_token1] = ACTIONS(412), + [aux_sym_output_stream_statement_token1] = ACTIONS(412), + [aux_sym_on_error_phrase_token1] = ACTIONS(412), + [aux_sym_stop_after_phrase_token1] = ACTIONS(412), + [aux_sym_do_tuning_token1] = ACTIONS(412), + [anon_sym_BY] = ACTIONS(412), + [aux_sym_where_clause_token1] = ACTIONS(412), + [aux_sym_query_tuning_token1] = ACTIONS(412), + [aux_sym_query_tuning_token2] = ACTIONS(412), + [aux_sym_query_tuning_token3] = ACTIONS(412), + [aux_sym_query_tuning_token4] = ACTIONS(412), + [aux_sym_query_tuning_token5] = ACTIONS(412), + [aux_sym_query_tuning_token6] = ACTIONS(412), + [aux_sym_of_token1] = ACTIONS(412), + [aux_sym__using_first_token1] = ACTIONS(412), + [aux_sym_field_definition_token1] = ACTIONS(412), + [aux_sym_index_definition_token1] = ACTIONS(412), + [aux_sym_on_statement_token1] = ACTIONS(412), + }, + [297] = { + [sym_comment] = STATE(297), + [sym_include] = STATE(297), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(414), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(416), + [anon_sym_LPAREN] = ACTIONS(416), + [anon_sym_RPAREN] = ACTIONS(416), + [aux_sym__logical_operator_token1] = ACTIONS(416), + [aux_sym__logical_operator_token2] = ACTIONS(416), + [aux_sym__logical_operator_token3] = ACTIONS(416), + [aux_sym__logical_operator_token4] = ACTIONS(416), + [aux_sym__logical_operator_token5] = ACTIONS(416), + [aux_sym__logical_operator_token6] = ACTIONS(416), + [anon_sym_PLUS] = ACTIONS(416), + [anon_sym_DASH] = ACTIONS(416), + [anon_sym_STAR] = ACTIONS(416), + [anon_sym_LT] = ACTIONS(414), + [anon_sym_LT_EQ] = ACTIONS(416), + [anon_sym_LT_GT] = ACTIONS(416), + [anon_sym_EQ] = ACTIONS(416), + [anon_sym_GT] = ACTIONS(414), + [anon_sym_GT_EQ] = ACTIONS(416), + [aux_sym__comparison_operator_token1] = ACTIONS(416), + [aux_sym__comparison_operator_token2] = ACTIONS(416), + [aux_sym__comparison_operator_token3] = ACTIONS(416), + [aux_sym__comparison_operator_token4] = ACTIONS(416), + [aux_sym__comparison_operator_token5] = ACTIONS(416), + [aux_sym__comparison_operator_token6] = ACTIONS(416), + [aux_sym__comparison_operator_token7] = ACTIONS(416), + [aux_sym__comparison_operator_token8] = ACTIONS(416), + [aux_sym__comparison_operator_token9] = ACTIONS(416), + [aux_sym_variable_tuning_token1] = ACTIONS(416), + [aux_sym_variable_tuning_token2] = ACTIONS(416), + [aux_sym_variable_tuning_token3] = ACTIONS(416), + [aux_sym_variable_tuning_token4] = ACTIONS(416), + [aux_sym_variable_tuning_token5] = ACTIONS(416), + [aux_sym_variable_tuning_token6] = ACTIONS(416), + [aux_sym_serialization_tuning_token1] = ACTIONS(416), + [anon_sym_COMMA] = ACTIONS(416), + [aux_sym_if_statement_token2] = ACTIONS(416), + [aux_sym_else_if_statement_token1] = ACTIONS(416), + [anon_sym_COLON] = ACTIONS(416), + [aux_sym_property_tuning_token1] = ACTIONS(416), + [aux_sym_property_definition_token2] = ACTIONS(416), + [aux_sym_inherits_token1] = ACTIONS(416), + [aux_sym_implements_token1] = ACTIONS(416), + [aux_sym_use_widget_pool_token1] = ACTIONS(416), + [aux_sym_final_token1] = ACTIONS(416), + [aux_sym_output_stream_statement_token1] = ACTIONS(416), + [aux_sym_on_error_phrase_token1] = ACTIONS(416), + [aux_sym_stop_after_phrase_token1] = ACTIONS(416), + [aux_sym_do_tuning_token1] = ACTIONS(416), + [anon_sym_BY] = ACTIONS(416), + [aux_sym_where_clause_token1] = ACTIONS(416), + [aux_sym_query_tuning_token1] = ACTIONS(416), + [aux_sym_query_tuning_token2] = ACTIONS(416), + [aux_sym_query_tuning_token3] = ACTIONS(416), + [aux_sym_query_tuning_token4] = ACTIONS(416), + [aux_sym_query_tuning_token5] = ACTIONS(416), + [aux_sym_query_tuning_token6] = ACTIONS(416), + [aux_sym_of_token1] = ACTIONS(416), + [aux_sym__using_first_token1] = ACTIONS(416), + [aux_sym_field_definition_token1] = ACTIONS(416), + [aux_sym_index_definition_token1] = ACTIONS(416), + [aux_sym_on_statement_token1] = ACTIONS(416), + }, + [298] = { + [sym_comment] = STATE(298), + [sym_include] = STATE(298), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(418), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(420), + [anon_sym_LPAREN] = ACTIONS(420), + [anon_sym_RPAREN] = ACTIONS(420), + [aux_sym__logical_operator_token1] = ACTIONS(420), + [aux_sym__logical_operator_token2] = ACTIONS(420), + [aux_sym__logical_operator_token3] = ACTIONS(420), + [aux_sym__logical_operator_token4] = ACTIONS(420), + [aux_sym__logical_operator_token5] = ACTIONS(420), + [aux_sym__logical_operator_token6] = ACTIONS(420), + [anon_sym_PLUS] = ACTIONS(420), + [anon_sym_DASH] = ACTIONS(420), + [anon_sym_STAR] = ACTIONS(420), + [anon_sym_LT] = ACTIONS(418), + [anon_sym_LT_EQ] = ACTIONS(420), + [anon_sym_LT_GT] = ACTIONS(420), + [anon_sym_EQ] = ACTIONS(420), + [anon_sym_GT] = ACTIONS(418), + [anon_sym_GT_EQ] = ACTIONS(420), + [aux_sym__comparison_operator_token1] = ACTIONS(420), + [aux_sym__comparison_operator_token2] = ACTIONS(420), + [aux_sym__comparison_operator_token3] = ACTIONS(420), + [aux_sym__comparison_operator_token4] = ACTIONS(420), + [aux_sym__comparison_operator_token5] = ACTIONS(420), + [aux_sym__comparison_operator_token6] = ACTIONS(420), + [aux_sym__comparison_operator_token7] = ACTIONS(420), + [aux_sym__comparison_operator_token8] = ACTIONS(420), + [aux_sym__comparison_operator_token9] = ACTIONS(420), + [aux_sym_variable_tuning_token1] = ACTIONS(420), + [aux_sym_variable_tuning_token2] = ACTIONS(420), + [aux_sym_variable_tuning_token3] = ACTIONS(420), + [aux_sym_variable_tuning_token4] = ACTIONS(420), + [aux_sym_variable_tuning_token5] = ACTIONS(420), + [aux_sym_variable_tuning_token6] = ACTIONS(420), + [aux_sym_serialization_tuning_token1] = ACTIONS(420), + [anon_sym_COMMA] = ACTIONS(420), + [aux_sym_if_statement_token2] = ACTIONS(420), + [aux_sym_else_if_statement_token1] = ACTIONS(420), + [anon_sym_COLON] = ACTIONS(420), + [aux_sym_property_tuning_token1] = ACTIONS(420), + [aux_sym_property_definition_token2] = ACTIONS(420), + [aux_sym_inherits_token1] = ACTIONS(420), + [aux_sym_implements_token1] = ACTIONS(420), + [aux_sym_use_widget_pool_token1] = ACTIONS(420), + [aux_sym_final_token1] = ACTIONS(420), + [aux_sym_output_stream_statement_token1] = ACTIONS(420), + [aux_sym_on_error_phrase_token1] = ACTIONS(420), + [aux_sym_stop_after_phrase_token1] = ACTIONS(420), + [aux_sym_do_tuning_token1] = ACTIONS(420), + [anon_sym_BY] = ACTIONS(420), + [aux_sym_where_clause_token1] = ACTIONS(420), + [aux_sym_query_tuning_token1] = ACTIONS(420), + [aux_sym_query_tuning_token2] = ACTIONS(420), + [aux_sym_query_tuning_token3] = ACTIONS(420), + [aux_sym_query_tuning_token4] = ACTIONS(420), + [aux_sym_query_tuning_token5] = ACTIONS(420), + [aux_sym_query_tuning_token6] = ACTIONS(420), + [aux_sym_of_token1] = ACTIONS(420), + [aux_sym__using_first_token1] = ACTIONS(420), + [aux_sym_field_definition_token1] = ACTIONS(420), + [aux_sym_index_definition_token1] = ACTIONS(420), + [aux_sym_on_statement_token1] = ACTIONS(420), + }, + [299] = { + [sym_comment] = STATE(299), + [sym_include] = STATE(299), + [anon_sym_SLASH_SLASH] = ACTIONS(57), + [anon_sym_SLASH_STAR] = ACTIONS(59), + [anon_sym_SLASH] = ACTIONS(422), + [anon_sym_LBRACE] = ACTIONS(63), + [sym__terminator] = ACTIONS(424), + [anon_sym_LPAREN] = ACTIONS(424), + [anon_sym_RPAREN] = ACTIONS(424), + [aux_sym__logical_operator_token1] = ACTIONS(424), + [aux_sym__logical_operator_token2] = ACTIONS(424), + [aux_sym__logical_operator_token3] = ACTIONS(424), + [aux_sym__logical_operator_token4] = ACTIONS(424), + [aux_sym__logical_operator_token5] = ACTIONS(424), + [aux_sym__logical_operator_token6] = ACTIONS(424), + [anon_sym_PLUS] = ACTIONS(424), + [anon_sym_DASH] = ACTIONS(424), + [anon_sym_STAR] = ACTIONS(424), + [anon_sym_LT] = ACTIONS(422), + [anon_sym_LT_EQ] = ACTIONS(424), + [anon_sym_LT_GT] = ACTIONS(424), + [anon_sym_EQ] = ACTIONS(424), + [anon_sym_GT] = ACTIONS(422), + [anon_sym_GT_EQ] = ACTIONS(424), + [aux_sym__comparison_operator_token1] = ACTIONS(424), + [aux_sym__comparison_operator_token2] = ACTIONS(424), + [aux_sym__comparison_operator_token3] = ACTIONS(424), + [aux_sym__comparison_operator_token4] = ACTIONS(424), + [aux_sym__comparison_operator_token5] = ACTIONS(424), + [aux_sym__comparison_operator_token6] = ACTIONS(424), + [aux_sym__comparison_operator_token7] = ACTIONS(424), + [aux_sym__comparison_operator_token8] = ACTIONS(424), + [aux_sym__comparison_operator_token9] = ACTIONS(424), + [aux_sym_variable_tuning_token1] = ACTIONS(424), + [aux_sym_variable_tuning_token2] = ACTIONS(424), + [aux_sym_variable_tuning_token3] = ACTIONS(424), + [aux_sym_variable_tuning_token4] = ACTIONS(424), + [aux_sym_variable_tuning_token5] = ACTIONS(424), + [aux_sym_variable_tuning_token6] = ACTIONS(424), + [aux_sym_query_definition_tuning_token1] = ACTIONS(424), + [anon_sym_SCROLLING] = ACTIONS(424), + [aux_sym_query_definition_tuning_token2] = ACTIONS(424), + [anon_sym_COMMA] = ACTIONS(424), + [aux_sym_if_statement_token2] = ACTIONS(424), + [aux_sym_else_if_statement_token1] = ACTIONS(424), + [anon_sym_COLON] = ACTIONS(424), + [aux_sym_property_definition_token2] = ACTIONS(424), + [aux_sym_output_stream_statement_token1] = ACTIONS(424), + [aux_sym_on_error_phrase_token1] = ACTIONS(424), + [aux_sym_stop_after_phrase_token1] = ACTIONS(424), + [aux_sym_do_tuning_token1] = ACTIONS(424), + [anon_sym_BY] = ACTIONS(424), + [aux_sym_where_clause_token1] = ACTIONS(424), + [aux_sym_query_tuning_token1] = ACTIONS(424), + [aux_sym_query_tuning_token2] = ACTIONS(424), + [aux_sym_query_tuning_token3] = ACTIONS(424), + [aux_sym_query_tuning_token4] = ACTIONS(424), + [aux_sym_query_tuning_token5] = ACTIONS(424), + [aux_sym_query_tuning_token6] = ACTIONS(424), + [aux_sym_of_token1] = ACTIONS(424), + [aux_sym__using_first_token1] = ACTIONS(424), + [aux_sym_field_definition_token1] = ACTIONS(424), + [aux_sym_index_definition_token1] = ACTIONS(424), + [aux_sym_on_statement_token1] = ACTIONS(424), + [sym__namedot] = ACTIONS(426), }, }; static const uint16_t ts_small_parse_table[] = { - [0] = 7, - ACTIONS(373), 1, + [0] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(416), 1, - sym__namedot, - STATE(283), 2, + STATE(300), 2, sym_comment, sym_include, - ACTIONS(412), 4, + ACTIONS(428), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(414), 54, + ACTIONS(430), 56, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -41184,7 +44893,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -41214,9 +44922,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -41224,27 +44935,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [79] = 6, - ACTIONS(373), 1, + [77] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(284), 2, + STATE(301), 2, sym_comment, sym_include, - ACTIONS(412), 4, + ACTIONS(422), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(414), 54, + ACTIONS(424), 56, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -41254,7 +44964,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -41284,9 +44993,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -41294,27 +45006,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [155] = 6, - ACTIONS(373), 1, + [154] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(285), 2, + STATE(302), 2, sym_comment, sym_include, - ACTIONS(418), 4, + ACTIONS(432), 4, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(420), 54, + aux_sym_object_access_token1, + ACTIONS(434), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -41324,7 +45036,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -41347,16 +45058,16 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_variable_tuning_token4, aux_sym_variable_tuning_token5, aux_sym_variable_tuning_token6, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -41364,31 +45075,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [231] = 8, - ACTIONS(373), 1, + [229] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(286), 2, + STATE(303), 2, sym_comment, sym_include, - ACTIONS(422), 4, + ACTIONS(436), 4, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(424), 51, + aux_sym_object_access_token1, + ACTIONS(438), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -41398,7 +45105,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -41425,9 +45131,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -41435,31 +45144,121 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [310] = 8, - ACTIONS(373), 1, + [304] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(287), 2, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(440), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3656), 1, + sym_argument_mode, + STATE(3752), 1, + sym__function_call_arguments, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(304), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [432] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(305), 2, sym_comment, sym_include, - ACTIONS(426), 4, + ACTIONS(442), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(428), 51, + ACTIONS(444), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -41469,7 +45268,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -41496,9 +45294,352 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [506] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(306), 2, + sym_comment, + sym_include, + ACTIONS(446), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(448), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [580] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(307), 2, + sym_comment, + sym_include, + ACTIONS(450), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(452), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [654] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(308), 2, + sym_comment, + sym_include, + ACTIONS(454), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(456), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [728] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(309), 2, + sym_comment, + sym_include, + ACTIONS(458), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(460), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [802] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(310), 2, + sym_comment, + sym_include, + ACTIONS(462), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(464), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -41506,87 +45647,87 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [389] = 33, + [876] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(142), 1, + anon_sym_RPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(430), 1, - anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(750), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3202), 1, - sym__function_call_arguments, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - ACTIONS(133), 2, + STATE(3659), 1, + sym__function_call_arguments, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(288), 2, + STATE(311), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -41606,82 +45747,150 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [517] = 33, + [1004] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(312), 2, + sym_comment, + sym_include, + ACTIONS(466), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(468), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [1078] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(432), 1, + ACTIONS(470), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3141), 1, - sym__function_call_arguments, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - ACTIONS(133), 2, + STATE(3660), 1, + sym__function_call_arguments, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(289), 2, + STATE(313), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -41701,82 +45910,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [645] = 33, + [1206] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(117), 1, - anon_sym_RPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(472), 1, + anon_sym_RPAREN, + STATE(301), 1, sym__decimal_literal, - STATE(692), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - STATE(3256), 1, + STATE(3788), 1, sym__function_call_arguments, - ACTIONS(133), 2, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(290), 2, + STATE(314), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -41796,82 +46005,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [773] = 33, + [1334] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(434), 1, + ACTIONS(474), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3136), 1, - sym__function_call_arguments, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - ACTIONS(133), 2, + STATE(3783), 1, + sym__function_call_arguments, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(291), 2, + STATE(315), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -41891,82 +46100,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [901] = 33, + [1462] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(436), 1, + ACTIONS(476), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3255), 1, - sym_argument_mode, - STATE(3262), 1, + STATE(3417), 1, sym__function_call_arguments, - ACTIONS(133), 2, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(292), 2, + STATE(316), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -41986,82 +46195,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [1029] = 33, + [1590] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(438), 1, + ACTIONS(478), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3255), 1, - sym_argument_mode, - STATE(3310), 1, + STATE(3613), 1, sym__function_call_arguments, - ACTIONS(133), 2, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(293), 2, + STATE(317), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -42081,82 +46290,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [1157] = 33, + [1718] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(440), 1, + ACTIONS(480), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3255), 1, - sym_argument_mode, - STATE(3304), 1, + STATE(3641), 1, sym__function_call_arguments, - ACTIONS(133), 2, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(294), 2, + STATE(318), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -42176,308 +46385,225 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [1285] = 33, - ACTIONS(3), 1, + [1846] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(442), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(3255), 1, - sym_argument_mode, - STATE(3274), 1, - sym__function_call_arguments, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(295), 2, + STATE(319), 2, sym_comment, sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [1413] = 33, - ACTIONS(3), 1, + ACTIONS(482), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(484), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [1920] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(444), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(2997), 1, - sym__function_call_arguments, - STATE(3255), 1, - sym_argument_mode, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(296), 2, + STATE(320), 2, sym_comment, sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [1541] = 33, - ACTIONS(3), 1, + ACTIONS(486), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(488), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [1994] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(446), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(3255), 1, - sym_argument_mode, - STATE(3298), 1, - sym__function_call_arguments, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(297), 2, + STATE(321), 2, sym_comment, sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [1669] = 6, - ACTIONS(373), 1, + ACTIONS(490), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(492), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [2068] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(298), 2, + STATE(322), 2, sym_comment, sym_include, - ACTIONS(448), 5, + ACTIONS(494), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_object_access_token1, - aux_sym_widget_field_token1, - ACTIONS(450), 51, + ACTIONS(496), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -42487,7 +46613,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -42514,9 +46639,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -42524,182 +46652,155 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [1743] = 33, - ACTIONS(3), 1, + [2142] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(452), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(3110), 1, - sym__function_call_arguments, - STATE(3255), 1, - sym_argument_mode, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(299), 2, + STATE(323), 2, sym_comment, sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [1871] = 33, + ACTIONS(498), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(500), 53, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [2216] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(454), 1, + ACTIONS(502), 1, anon_sym_RPAREN, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3027), 1, + STATE(3508), 1, sym__function_call_arguments, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - ACTIONS(133), 2, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(300), 2, + STATE(324), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -42719,82 +46820,82 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [1999] = 33, + [2344] = 33, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(117), 1, + ACTIONS(142), 1, anon_sym_RPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, + ACTIONS(154), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(693), 1, + STATE(746), 1, sym__expression, - STATE(2206), 1, + STATE(2866), 1, sym_function_call_argument, - STATE(2572), 1, + STATE(3075), 1, sym__function_argument_with_mode, - STATE(3255), 1, + STATE(3656), 1, sym_argument_mode, - STATE(3256), 1, + STATE(3659), 1, sym__function_call_arguments, - ACTIONS(133), 2, + ACTIONS(158), 2, aux_sym_argument_mode_token1, aux_sym_argument_mode_token2, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(301), 2, + STATE(325), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -42814,214 +46915,22 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [2127] = 33, - ACTIONS(3), 1, + [2472] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(456), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(3113), 1, - sym__function_call_arguments, - STATE(3255), 1, - sym_argument_mode, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(302), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [2255] = 33, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(129), 1, - aux_sym_input_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(458), 1, - anon_sym_RPAREN, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2206), 1, - sym_function_call_argument, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(3116), 1, - sym__function_call_arguments, - STATE(3255), 1, - sym_argument_mode, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(303), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [2383] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(304), 2, - sym_comment, - sym_include, - ACTIONS(460), 5, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_object_access_token1, - aux_sym_widget_field_token1, - ACTIONS(462), 51, - sym__terminator, + STATE(326), 2, + sym_comment, + sym_include, + ACTIONS(504), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(506), 53, + sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, aux_sym__logical_operator_token1, @@ -43030,7 +46939,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43057,9 +46965,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43067,27 +46978,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2457] = 6, - ACTIONS(373), 1, + [2546] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(305), 2, + STATE(327), 2, sym_comment, sym_include, - ACTIONS(464), 4, + ACTIONS(508), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(466), 51, + ACTIONS(510), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43097,7 +47007,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43124,9 +47033,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43134,27 +47046,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2530] = 6, - ACTIONS(373), 1, + [2620] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(306), 2, + STATE(328), 2, sym_comment, sym_include, - ACTIONS(468), 4, + ACTIONS(512), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(470), 51, + ACTIONS(514), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43164,7 +47075,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43191,9 +47101,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43201,27 +47114,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2603] = 6, - ACTIONS(373), 1, + [2694] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(307), 2, + STATE(329), 2, sym_comment, sym_include, - ACTIONS(472), 4, + ACTIONS(516), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(474), 51, + ACTIONS(518), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43231,7 +47143,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43258,9 +47169,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43268,27 +47182,121 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2676] = 6, - ACTIONS(373), 1, + [2768] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - STATE(308), 2, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(520), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3656), 1, + sym_argument_mode, + STATE(3749), 1, + sym__function_call_arguments, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(330), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [2896] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(331), 2, sym_comment, sym_include, - ACTIONS(476), 4, + ACTIONS(522), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(478), 51, + ACTIONS(524), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43298,7 +47306,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43325,9 +47332,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43335,94 +47345,311 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2749] = 6, - ACTIONS(373), 1, + [2970] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - STATE(309), 2, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(526), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3656), 1, + sym_argument_mode, + STATE(3746), 1, + sym__function_call_arguments, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(332), 2, sym_comment, sym_include, - ACTIONS(480), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(482), 51, - sym__terminator, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3098] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(528), 1, anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [2822] = 6, - ACTIONS(373), 1, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3656), 1, + sym_argument_mode, + STATE(3743), 1, + sym__function_call_arguments, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(333), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3226] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - STATE(310), 2, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(530), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3394), 1, + sym__function_call_arguments, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(334), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3354] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(335), 2, sym_comment, sym_include, - ACTIONS(484), 4, + ACTIONS(532), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(486), 51, + ACTIONS(534), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43432,7 +47659,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43459,9 +47685,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43469,99 +47698,216 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [2895] = 11, - ACTIONS(373), 1, + [3428] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(488), 1, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(490), 1, - aux_sym_object_access_token1, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(335), 1, - aux_sym_object_access_repeat1, - STATE(311), 2, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(536), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3377), 1, + sym__function_call_arguments, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(336), 2, sym_comment, sym_include, - ACTIONS(484), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(486), 46, - sym__terminator, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3556] = 33, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(538), 1, anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [2978] = 6, - ACTIONS(373), 1, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3562), 1, + sym__function_call_arguments, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(337), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3684] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(312), 2, + STATE(338), 2, sym_comment, sym_include, - ACTIONS(492), 4, + ACTIONS(540), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(494), 51, + ACTIONS(542), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43571,7 +47917,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43598,9 +47943,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43608,27 +47956,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3051] = 6, - ACTIONS(373), 1, + [3758] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(313), 2, + STATE(339), 2, sym_comment, sym_include, - ACTIONS(496), 4, + ACTIONS(544), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(498), 51, + ACTIONS(546), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43638,7 +47985,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43665,9 +48011,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43675,99 +48024,121 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3124] = 11, - ACTIONS(373), 1, + [3832] = 33, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(488), 1, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(490), 1, - aux_sym_object_access_token1, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(335), 1, - aux_sym_object_access_repeat1, - STATE(314), 2, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(548), 1, + anon_sym_RPAREN, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(2866), 1, + sym_function_call_argument, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3648), 1, + sym__function_call_arguments, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(340), 2, sym_comment, sym_include, - ACTIONS(500), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(502), 46, - sym__terminator, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [3207] = 6, - ACTIONS(373), 1, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [3960] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(315), 2, + STATE(341), 2, sym_comment, sym_include, - ACTIONS(500), 4, + ACTIONS(550), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(502), 51, + ACTIONS(552), 53, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43777,7 +48148,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43804,9 +48174,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -43814,27 +48187,30 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3280] = 6, - ACTIONS(373), 1, + [4034] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(316), 2, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(342), 2, sym_comment, sym_include, - ACTIONS(504), 4, + ACTIONS(544), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(506), 51, + ACTIONS(546), 50, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43844,7 +48220,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43871,8 +48246,8 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, @@ -43881,27 +48256,30 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3353] = 6, - ACTIONS(373), 1, + [4111] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(317), 2, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(343), 2, sym_comment, sym_include, - ACTIONS(426), 4, + ACTIONS(446), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(428), 51, + ACTIONS(448), 50, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -43911,7 +48289,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -43938,8 +48315,8 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, @@ -43948,29 +48325,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3426] = 6, - ACTIONS(373), 1, + [4188] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(318), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(556), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(353), 1, + aux_sym_object_access_repeat1, + STATE(344), 2, sym_comment, sym_include, - ACTIONS(422), 4, + ACTIONS(454), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(424), 51, + ACTIONS(456), 47, sym__terminator, - anon_sym_LPAREN, anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, @@ -43978,7 +48363,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -44004,10 +48388,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -44015,29 +48397,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3499] = 6, - ACTIONS(373), 1, + [4271] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(319), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(556), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(353), 1, + aux_sym_object_access_repeat1, + STATE(345), 2, sym_comment, sym_include, - ACTIONS(508), 4, + ACTIONS(532), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(510), 51, + ACTIONS(534), 47, sym__terminator, - anon_sym_LPAREN, anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, @@ -44045,7 +48435,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -44071,10 +48460,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -44082,104 +48469,399 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3572] = 6, - ACTIONS(373), 1, + [4354] = 31, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - STATE(320), 2, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(154), 1, + aux_sym_input_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + STATE(301), 1, + sym__decimal_literal, + STATE(746), 1, + sym__expression, + STATE(3075), 1, + sym__function_argument_with_mode, + STATE(3221), 1, + sym_function_call_argument, + STATE(3656), 1, + sym_argument_mode, + ACTIONS(158), 2, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(346), 2, sym_comment, sym_include, - ACTIONS(512), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(514), 51, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [3645] = 6, - ACTIONS(373), 1, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [4476] = 31, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, anon_sym_LBRACE, - STATE(321), 2, - sym_comment, - sym_include, - ACTIONS(516), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(518), 51, + ACTIONS(562), 1, sym__terminator, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(574), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(588), 1, + anon_sym_EQ, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(594), 1, + anon_sym_COLON, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + STATE(357), 1, + sym__expression, + STATE(372), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(347), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [4597] = 31, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(574), 1, + anon_sym_LPAREN, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(588), 1, + anon_sym_EQ, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(602), 1, + sym__terminator, + ACTIONS(604), 1, + anon_sym_COLON, + STATE(357), 1, + sym__expression, + STATE(375), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(348), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [4718] = 31, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(574), 1, + anon_sym_LPAREN, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(588), 1, + anon_sym_EQ, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(594), 1, + anon_sym_COLON, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(606), 1, + sym__terminator, + STATE(357), 1, + sym__expression, + STATE(374), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(349), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [4839] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(612), 1, + aux_sym_object_access_token1, + ACTIONS(608), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + STATE(350), 3, + sym_comment, + sym_include, + aux_sym_object_access_repeat1, + ACTIONS(610), 48, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -44205,10 +48887,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -44216,27 +48896,210 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3718] = 6, - ACTIONS(373), 1, + [4912] = 31, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, anon_sym_LBRACE, - STATE(322), 2, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(574), 1, + anon_sym_LPAREN, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(588), 1, + anon_sym_EQ, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(615), 1, + sym__terminator, + ACTIONS(617), 1, + anon_sym_COLON, + STATE(357), 1, + sym__expression, + STATE(376), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(351), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [5033] = 31, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(574), 1, + anon_sym_LPAREN, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(588), 1, + anon_sym_EQ, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(594), 1, + anon_sym_COLON, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(619), 1, + sym__terminator, + STATE(357), 1, + sym__expression, + STATE(371), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(352), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [5154] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(556), 1, + aux_sym_object_access_token1, + STATE(350), 1, + aux_sym_object_access_repeat1, + STATE(353), 2, sym_comment, sym_include, - ACTIONS(520), 4, + ACTIONS(621), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(522), 51, + ACTIONS(623), 48, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -44246,7 +49109,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -44272,10 +49134,8 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -44283,43 +49143,61 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [3791] = 6, - ACTIONS(373), 1, + [5229] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(323), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + STATE(354), 2, sym_comment, sym_include, - ACTIONS(524), 4, + ACTIONS(625), 49, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(526), 51, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44330,63 +49208,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [3864] = 6, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [5303] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(324), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(355), 2, sym_comment, sym_include, - ACTIONS(528), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(530), 51, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44397,63 +49259,82 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [3937] = 6, - ACTIONS(373), 1, + ACTIONS(627), 24, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [5385] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(325), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + STATE(356), 2, sym_comment, sym_include, - ACTIONS(532), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(534), 51, + ACTIONS(637), 47, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44464,63 +49345,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [4010] = 6, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [5461] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(326), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(357), 2, sym_comment, sym_include, - ACTIONS(536), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(538), 51, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44531,63 +49396,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [4083] = 6, - ACTIONS(373), 1, + ACTIONS(639), 24, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [5543] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(327), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(358), 2, sym_comment, sym_include, - ACTIONS(540), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(542), 51, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44598,247 +49466,136 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [4156] = 31, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(641), 24, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, anon_sym_LPAREN, - ACTIONS(119), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, aux_sym_locked_expression_token1, - ACTIONS(129), 1, aux_sym_input_expression_token1, - ACTIONS(131), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(693), 1, - sym__expression, - STATE(2572), 1, - sym__function_argument_with_mode, - STATE(2792), 1, - sym_function_call_argument, - STATE(3255), 1, - sym_argument_mode, - ACTIONS(133), 2, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - ACTIONS(143), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(328), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4278] = 31, + [5625] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(359), 2, + sym_comment, + sym_include, + ACTIONS(631), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(635), 15, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + ACTIONS(643), 24, anon_sym_LBRACE, - ACTIONS(548), 1, + sym_identifier, sym__terminator, - ACTIONS(550), 1, sym_null_expression, - ACTIONS(554), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(556), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, anon_sym_SQUOTE, - ACTIONS(560), 1, anon_sym_LPAREN, - ACTIONS(562), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, aux_sym_input_expression_token1, - ACTIONS(574), 1, - anon_sym_EQ, - ACTIONS(576), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, aux_sym_if_statement_token1, - ACTIONS(580), 1, - anon_sym_COLON, - ACTIONS(582), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, aux_sym_accumulate_expression_token1, - STATE(342), 1, - sym__expression, - STATE(353), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(329), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4399] = 7, - ACTIONS(373), 1, + [5707] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(592), 1, - aux_sym_object_access_token1, - STATE(330), 3, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(360), 2, sym_comment, sym_include, - aux_sym_object_access_repeat1, - ACTIONS(588), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(590), 47, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -44849,549 +49606,130 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [4472] = 31, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + ACTIONS(645), 24, anon_sym_LBRACE, - ACTIONS(550), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(554), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(556), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, anon_sym_SQUOTE, - ACTIONS(560), 1, anon_sym_LPAREN, - ACTIONS(562), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, aux_sym_input_expression_token1, - ACTIONS(574), 1, - anon_sym_EQ, - ACTIONS(576), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, aux_sym_accumulate_expression_token1, - ACTIONS(595), 1, - sym__terminator, - ACTIONS(597), 1, - anon_sym_COLON, - STATE(342), 1, - sym__expression, - STATE(354), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(331), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4593] = 31, + [5789] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(361), 2, + sym_comment, + sym_include, + ACTIONS(635), 15, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + ACTIONS(550), 30, anon_sym_LBRACE, - ACTIONS(550), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(554), 1, - sym__integer_literal, - ACTIONS(556), 1, - anon_sym_DQUOTE, - ACTIONS(558), 1, - anon_sym_SQUOTE, - ACTIONS(560), 1, - anon_sym_LPAREN, - ACTIONS(562), 1, - aux_sym_unary_expression_token1, - ACTIONS(564), 1, - aux_sym_unary_expression_token2, - ACTIONS(566), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, - aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(574), 1, - anon_sym_EQ, - ACTIONS(576), 1, - aux_sym_scope_tuning_token1, - ACTIONS(578), 1, - aux_sym_if_statement_token1, - ACTIONS(582), 1, - aux_sym_can_find_expression_token1, - ACTIONS(584), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(599), 1, - sym__terminator, - ACTIONS(601), 1, - anon_sym_COLON, - STATE(342), 1, - sym__expression, - STATE(356), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(332), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4714] = 31, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, - anon_sym_LBRACE, - ACTIONS(550), 1, - sym_null_expression, - ACTIONS(554), 1, - sym__integer_literal, - ACTIONS(556), 1, - anon_sym_DQUOTE, - ACTIONS(558), 1, - anon_sym_SQUOTE, - ACTIONS(560), 1, - anon_sym_LPAREN, - ACTIONS(562), 1, - aux_sym_unary_expression_token1, - ACTIONS(564), 1, - aux_sym_unary_expression_token2, - ACTIONS(566), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, - aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(574), 1, - anon_sym_EQ, - ACTIONS(576), 1, - aux_sym_scope_tuning_token1, - ACTIONS(578), 1, - aux_sym_if_statement_token1, - ACTIONS(580), 1, - anon_sym_COLON, - ACTIONS(582), 1, - aux_sym_can_find_expression_token1, - ACTIONS(584), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(603), 1, - sym__terminator, - STATE(342), 1, - sym__expression, - STATE(358), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(333), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4835] = 31, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, - anon_sym_LBRACE, - ACTIONS(550), 1, - sym_null_expression, - ACTIONS(554), 1, sym__integer_literal, - ACTIONS(556), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, anon_sym_SQUOTE, - ACTIONS(560), 1, anon_sym_LPAREN, - ACTIONS(562), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(564), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, aux_sym_input_expression_token1, - ACTIONS(574), 1, - anon_sym_EQ, - ACTIONS(576), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, aux_sym_if_statement_token1, - ACTIONS(580), 1, - anon_sym_COLON, - ACTIONS(582), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, aux_sym_accumulate_expression_token1, - ACTIONS(605), 1, - sym__terminator, - STATE(342), 1, - sym__expression, - STATE(357), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(334), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [4956] = 8, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(490), 1, - aux_sym_object_access_token1, - STATE(330), 1, - aux_sym_object_access_repeat1, - STATE(335), 2, - sym_comment, - sym_include, - ACTIONS(607), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(609), 47, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [5031] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(615), 1, - anon_sym_LPAREN, - STATE(336), 2, - sym_comment, - sym_include, - ACTIONS(611), 4, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(613), 47, - sym__terminator, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_object_access_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_on_statement_token1, - [5103] = 12, + [5869] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, + STATE(475), 1, sym__logical_operator, - STATE(497), 1, + STATE(482), 1, sym__additive_operator, - ACTIONS(619), 2, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(337), 2, + STATE(362), 2, sym_comment, sym_include, - ACTIONS(621), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -45407,7 +49745,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(617), 24, + ACTIONS(647), 24, anon_sym_LBRACE, sym_identifier, sym__terminator, @@ -45432,36 +49770,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5185] = 12, + [5951] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(338), 2, + ACTIONS(649), 1, + anon_sym_LPAREN, + ACTIONS(651), 1, + aux_sym_object_access_token1, + ACTIONS(653), 1, + sym__namedot, + STATE(378), 1, + aux_sym_object_access_repeat1, + STATE(380), 1, + aux_sym_qualified_name_repeat1, + STATE(363), 2, sym_comment, sym_include, - ACTIONS(621), 6, + ACTIONS(454), 48, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -45477,61 +49831,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(627), 24, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5267] = 12, + [6027] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, + STATE(475), 1, sym__logical_operator, - STATE(497), 1, + STATE(482), 1, sym__additive_operator, - ACTIONS(619), 2, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(339), 2, + STATE(364), 2, sym_comment, sym_include, - ACTIONS(621), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -45547,7 +49882,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(629), 24, + ACTIONS(655), 24, anon_sym_LBRACE, sym_identifier, sym__terminator, @@ -45572,36 +49907,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5349] = 12, + [6109] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(340), 2, + ACTIONS(649), 1, + anon_sym_LPAREN, + ACTIONS(651), 1, + aux_sym_object_access_token1, + ACTIONS(653), 1, + sym__namedot, + STATE(378), 1, + aux_sym_object_access_repeat1, + STATE(380), 1, + aux_sym_qualified_name_repeat1, + STATE(365), 2, sym_comment, sym_include, - ACTIONS(621), 6, + ACTIONS(532), 48, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -45617,47 +49968,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(631), 24, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5431] = 6, - ACTIONS(373), 1, + [6185] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(341), 2, + STATE(366), 2, sym_comment, sym_include, - ACTIONS(633), 4, + ACTIONS(432), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(635), 48, + ACTIONS(434), 49, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -45667,7 +49998,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -45693,9 +50023,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, aux_sym_object_access_token1, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -45705,42 +50035,39 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [5501] = 12, - ACTIONS(3), 1, + [6255] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(342), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(367), 2, sym_comment, sym_include, - ACTIONS(621), 6, + ACTIONS(657), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(659), 49, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -45751,47 +50078,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(637), 24, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_object_access_token1, + aux_sym_output_stream_statement_token1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [6325] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [5583] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(343), 2, + STATE(368), 2, sym_comment, sym_include, - ACTIONS(460), 4, + ACTIONS(436), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(462), 48, + ACTIONS(438), 49, sym__terminator, anon_sym_LPAREN, anon_sym_RPAREN, @@ -45801,7 +50126,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -45827,9 +50151,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, aux_sym_object_access_token1, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -45839,25 +50163,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [5653] = 6, - ACTIONS(373), 1, + [6395] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(344), 2, + ACTIONS(665), 1, + anon_sym_LPAREN, + STATE(369), 2, sym_comment, sym_include, - ACTIONS(448), 4, + ACTIONS(661), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(450), 48, + ACTIONS(663), 48, sym__terminator, - anon_sym_LPAREN, anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, @@ -45865,7 +50191,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -45891,9 +50216,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, + aux_sym_property_definition_token2, aux_sym_object_access_token1, + aux_sym_output_stream_statement_token1, aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, @@ -45903,27 +50228,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [5723] = 9, + [6467] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(639), 1, - anon_sym_LPAREN, - ACTIONS(641), 1, - aux_sym_object_access_token1, - ACTIONS(643), 1, - sym__namedot, - STATE(368), 1, - aux_sym_object_access_repeat1, - STATE(369), 1, - aux_sym_qualified_name_repeat1, - STATE(345), 2, + STATE(475), 1, + sym__logical_operator, + STATE(482), 1, + sym__additive_operator, + STATE(483), 1, + sym__multiplicative_operator, + STATE(486), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(370), 2, sym_comment, sym_include, - ACTIONS(484), 48, - anon_sym_SLASH, + ACTIONS(667), 45, anon_sym_LBRACE, sym_identifier, sym__terminator, @@ -45935,6 +50265,7 @@ static const uint16_t ts_small_parse_table[] = { sym__integer_literal, anon_sym_DQUOTE, anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -45947,9 +50278,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_current_changed_expression_token1, aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -45971,550 +50299,502 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5799] = 10, + [6545] = 29, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(346), 2, - sym_comment, - sym_include, - ACTIONS(645), 45, - anon_sym_LBRACE, + ACTIONS(558), 1, sym_identifier, - sym__terminator, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, + ACTIONS(669), 1, + sym__terminator, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(357), 1, + sym__expression, + STATE(373), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5877] = 8, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - STATE(347), 2, + STATE(371), 2, sym_comment, sym_include, - ACTIONS(647), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [6660] = 29, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, + ACTIONS(671), 1, + anon_sym_LPAREN, + ACTIONS(673), 1, + sym__terminator, + STATE(357), 1, + sym__expression, + STATE(373), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [5951] = 11, + STATE(372), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [6775] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(348), 2, - sym_comment, - sym_include, - ACTIONS(625), 15, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - ACTIONS(468), 30, - anon_sym_LBRACE, + ACTIONS(675), 1, sym_identifier, + ACTIONS(678), 1, + anon_sym_LBRACE, + ACTIONS(681), 1, sym__terminator, + ACTIONS(683), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(689), 1, sym__integer_literal, + ACTIONS(692), 1, anon_sym_DQUOTE, + ACTIONS(695), 1, anon_sym_SQUOTE, + ACTIONS(698), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(701), 1, aux_sym_unary_expression_token1, + ACTIONS(704), 1, aux_sym_unary_expression_token2, + ACTIONS(707), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(710), 1, aux_sym_current_changed_expression_token1, + ACTIONS(713), 1, aux_sym_locked_expression_token1, + ACTIONS(716), 1, aux_sym_input_expression_token1, + ACTIONS(719), 1, aux_sym_scope_tuning_token1, + ACTIONS(722), 1, aux_sym_if_statement_token1, + ACTIONS(725), 1, aux_sym_can_find_expression_token1, + ACTIONS(728), 1, aux_sym_accumulate_expression_token1, + STATE(357), 1, + sym__expression, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(731), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [6031] = 9, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(639), 1, - anon_sym_LPAREN, - ACTIONS(641), 1, - aux_sym_object_access_token1, - ACTIONS(643), 1, - sym__namedot, - STATE(368), 1, - aux_sym_object_access_repeat1, - STATE(369), 1, - aux_sym_qualified_name_repeat1, - STATE(349), 2, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(373), 3, sym_comment, sym_include, - ACTIONS(500), 48, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + aux_sym_abl_statement_repeat1, + ACTIONS(686), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [6888] = 29, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, + ACTIONS(671), 1, + anon_sym_LPAREN, + ACTIONS(734), 1, + sym__terminator, + STATE(357), 1, + sym__expression, + STATE(373), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [6107] = 9, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - STATE(350), 2, + STATE(374), 2, sym_comment, sym_include, - ACTIONS(649), 47, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [7003] = 29, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, + ACTIONS(671), 1, + anon_sym_LPAREN, + ACTIONS(736), 1, + sym__terminator, + STATE(357), 1, + sym__expression, + STATE(373), 1, + aux_sym_abl_statement_repeat1, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [6183] = 12, + STATE(375), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [7118] = 29, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(351), 2, - sym_comment, - sym_include, - ACTIONS(621), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - ACTIONS(651), 24, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [6265] = 12, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(386), 1, - sym__multiplicative_operator, - STATE(435), 1, - sym__comparison_operator, - STATE(496), 1, - sym__logical_operator, - STATE(497), 1, - sym__additive_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(352), 2, - sym_comment, - sym_include, - ACTIONS(621), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - ACTIONS(653), 24, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [6347] = 29, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - ACTIONS(655), 1, - sym__terminator, - ACTIONS(657), 1, + ACTIONS(671), 1, anon_sym_LPAREN, - STATE(342), 1, + ACTIONS(738), 1, + sym__terminator, + STATE(357), 1, sym__expression, - STATE(355), 1, + STATE(373), 1, aux_sym_abl_statement_repeat1, - STATE(518), 1, + STATE(573), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(353), 2, + STATE(376), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(547), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -46534,244 +50814,195 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [6462] = 29, + [7233] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + ACTIONS(653), 1, + sym__namedot, + STATE(380), 1, + aux_sym_qualified_name_repeat1, + STATE(377), 2, + sym_comment, + sym_include, + ACTIONS(544), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(550), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(554), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(556), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + anon_sym_LPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(564), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(659), 1, - sym__terminator, - STATE(342), 1, - sym__expression, - STATE(355), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(354), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [6577] = 28, + [7301] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(661), 1, - sym_identifier, - ACTIONS(664), 1, + ACTIONS(651), 1, + aux_sym_object_access_token1, + STATE(384), 1, + aux_sym_object_access_repeat1, + STATE(378), 2, + sym_comment, + sym_include, + ACTIONS(621), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(667), 1, + sym_identifier, sym__terminator, - ACTIONS(669), 1, sym_null_expression, - ACTIONS(675), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(678), 1, anon_sym_DQUOTE, - ACTIONS(681), 1, anon_sym_SQUOTE, - ACTIONS(684), 1, anon_sym_LPAREN, - ACTIONS(687), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(690), 1, aux_sym_unary_expression_token2, - ACTIONS(693), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(696), 1, aux_sym_current_changed_expression_token1, - ACTIONS(699), 1, aux_sym_locked_expression_token1, - ACTIONS(702), 1, aux_sym_input_expression_token1, - ACTIONS(705), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(708), 1, aux_sym_if_statement_token1, - ACTIONS(711), 1, aux_sym_can_find_expression_token1, - ACTIONS(714), 1, aux_sym_accumulate_expression_token1, - STATE(342), 1, - sym__expression, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(717), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(355), 3, - sym_comment, - sym_include, - aux_sym_abl_statement_repeat1, - ACTIONS(672), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [6690] = 29, + [7369] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(720), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(740), 1, sym__terminator, - STATE(342), 1, - sym__expression, - STATE(355), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(778), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(356), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(379), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -46791,159 +51022,133 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [6805] = 29, + [7481] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + ACTIONS(653), 1, + sym__namedot, + STATE(385), 1, + aux_sym_qualified_name_repeat1, + STATE(380), 2, + sym_comment, + sym_include, + ACTIONS(61), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(550), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(554), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(556), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + anon_sym_LPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(564), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(722), 1, - sym__terminator, - STATE(342), 1, - sym__expression, - STATE(355), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, - sym__decimal_literal, - ACTIONS(586), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(357), 2, - sym_comment, - sym_include, - STATE(520), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(552), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(540), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(534), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [6920] = 29, + [7549] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(724), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(742), 1, sym__terminator, - STATE(342), 1, - sym__expression, - STATE(355), 1, - aux_sym_abl_statement_repeat1, - STATE(518), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(836), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(358), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(381), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -46963,71 +51168,71 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [7035] = 28, + [7661] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(726), 1, + ACTIONS(744), 1, sym__terminator, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(763), 1, + STATE(854), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(359), 2, + STATE(382), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47047,18 +51252,19 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [7147] = 5, + [7773] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(728), 1, + ACTIONS(653), 1, sym__namedot, - STATE(360), 3, + STATE(380), 1, + aux_sym_qualified_name_repeat1, + STATE(383), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 49, + ACTIONS(446), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -47108,248 +51314,79 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [7213] = 28, + [7841] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(746), 1, + aux_sym_object_access_token1, + STATE(384), 3, + sym_comment, + sym_include, + aux_sym_object_access_repeat1, + ACTIONS(608), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(121), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(731), 1, - sym__terminator, - STATE(284), 1, - sym__decimal_literal, - STATE(711), 1, - sym__expression, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(361), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [7325] = 28, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(733), 1, - sym__terminator, - STATE(284), 1, - sym__decimal_literal, - STATE(740), 1, - sym__expression, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(362), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [7437] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(735), 1, - aux_sym_object_access_token1, - STATE(363), 3, - sym_comment, - sym_include, - aux_sym_object_access_repeat1, - ACTIONS(588), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [7503] = 6, + [7907] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(643), 1, + ACTIONS(749), 1, sym__namedot, - STATE(369), 1, - aux_sym_qualified_name_repeat1, - STATE(364), 2, + STATE(385), 3, sym_comment, sym_include, - ACTIONS(426), 49, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -47399,71 +51436,71 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [7571] = 28, + [7973] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(738), 1, + ACTIONS(752), 1, sym__terminator, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(758), 1, + STATE(783), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(365), 2, + STATE(386), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47483,133 +51520,71 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [7683] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(643), 1, - sym__namedot, - STATE(369), 1, - aux_sym_qualified_name_repeat1, - STATE(366), 2, - sym_comment, - sym_include, - ACTIONS(422), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [7751] = 28, + [8085] = 28, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(740), 1, + ACTIONS(754), 1, sym__terminator, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(745), 1, + STATE(809), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(367), 2, + STATE(387), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47629,81 +51604,97 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [7863] = 6, + [8197] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(641), 1, - aux_sym_object_access_token1, - STATE(363), 1, - aux_sym_object_access_repeat1, - STATE(368), 2, - sym_comment, - sym_include, - ACTIONS(607), 49, - anon_sym_SLASH, + ACTIONS(128), 1, anon_sym_LBRACE, - sym_identifier, - sym__terminator, + ACTIONS(130), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(134), 1, sym__integer_literal, + ACTIONS(136), 1, anon_sym_DQUOTE, + ACTIONS(138), 1, anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, + ACTIONS(768), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_scope_tuning_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, + STATE(301), 1, + sym__decimal_literal, + STATE(675), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [7931] = 6, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(388), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [8306] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(643), 1, - sym__namedot, - STATE(360), 1, - aux_sym_qualified_name_repeat1, - STATE(369), 2, + STATE(389), 2, sym_comment, sym_include, - ACTIONS(377), 49, + ACTIONS(436), 50, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -47749,73 +51740,74 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, + aux_sym_object_access_token1, aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [7999] = 27, + [8369] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(806), 1, + aux_sym_can_find_expression_token1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(569), 1, + STATE(691), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(370), 2, + STATE(390), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47835,69 +51827,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8108] = 27, + [8478] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(608), 1, - sym__expression, - STATE(640), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(701), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(371), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(391), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47917,69 +51909,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8217] = 27, + [8587] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(551), 1, + STATE(604), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(372), 2, + STATE(392), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -47999,69 +51991,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8326] = 27, + [8696] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(750), 1, + STATE(695), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(373), 2, + STATE(393), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48081,69 +52073,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8435] = 27, + [8805] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(615), 1, + STATE(696), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(374), 2, + STATE(394), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48163,69 +52155,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8544] = 27, + [8914] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(552), 1, + STATE(697), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(375), 2, + STATE(395), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48245,69 +52237,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8653] = 27, + [9023] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, + ACTIONS(756), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(723), 1, + STATE(699), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(376), 2, + STATE(396), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48327,69 +52319,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8762] = 27, + [9132] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(800), 1, + aux_sym_input_expression_token1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(710), 1, + STATE(674), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(377), 2, + STATE(397), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48409,69 +52401,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8871] = 27, + [9241] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, + ACTIONS(756), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(702), 1, + STATE(698), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(378), 2, + STATE(398), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48491,69 +52483,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [8980] = 27, + [9350] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(614), 1, + STATE(823), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(379), 2, + STATE(399), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48573,69 +52565,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9089] = 27, + [9459] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, - sym_identifier, - ACTIONS(798), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(768), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, - aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, - aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - STATE(664), 1, - sym__expression, - STATE(782), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(689), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(380), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(400), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48655,69 +52647,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9198] = 27, + [9568] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(800), 1, + aux_sym_input_expression_token1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(766), 1, + STATE(694), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(381), 2, + STATE(401), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48737,69 +52729,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9307] = 27, + [9677] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, + ACTIONS(756), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(705), 1, + STATE(688), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(382), 2, + STATE(402), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48819,69 +52811,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9416] = 27, + [9786] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(721), 1, + STATE(687), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(383), 2, + STATE(403), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48901,69 +52893,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9525] = 27, + [9895] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, + ACTIONS(756), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(768), 1, + aux_sym_input_expression_token1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(695), 1, + STATE(682), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(384), 2, + STATE(404), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -48983,69 +52975,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9634] = 27, + [10004] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(673), 1, + STATE(693), 1, sym__expression, - STATE(782), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(832), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(385), 2, + STATE(405), 2, sym_comment, sym_include, - STATE(781), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49065,69 +53057,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9743] = 27, + [10113] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(788), 1, + anon_sym_LPAREN, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(347), 1, + STATE(680), 1, sym__expression, - STATE(518), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(386), 2, + STATE(406), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49147,69 +53139,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9852] = 27, + [10222] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(736), 1, + STATE(752), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(387), 2, + STATE(407), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49229,69 +53221,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [9961] = 27, + [10331] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, - aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(672), 1, - sym__expression, - STATE(782), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(580), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(388), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(408), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49311,69 +53303,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10070] = 27, + [10440] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, - aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(671), 1, - sym__expression, - STATE(782), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(579), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(389), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(409), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49393,69 +53385,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10179] = 27, + [10549] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(622), 1, + STATE(577), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(390), 2, + STATE(410), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49475,69 +53467,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10288] = 27, + [10658] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(713), 1, + STATE(576), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(391), 2, + STATE(411), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49557,69 +53549,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10397] = 27, + [10767] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(788), 1, + anon_sym_LPAREN, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(351), 1, + STATE(683), 1, sym__expression, - STATE(518), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(392), 2, + STATE(412), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49639,129 +53631,151 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10506] = 5, + [10876] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(834), 1, - anon_sym_NO_DASHERROR, - STATE(393), 2, - sym_comment, - sym_include, - ACTIONS(472), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(774), 1, sym_identifier, - sym__terminator, + ACTIONS(776), 1, + anon_sym_LBRACE, + ACTIONS(778), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(782), 1, sym__integer_literal, + ACTIONS(784), 1, anon_sym_DQUOTE, + ACTIONS(786), 1, anon_sym_SQUOTE, + ACTIONS(788), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(790), 1, aux_sym_unary_expression_token1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, + ACTIONS(804), 1, aux_sym_if_statement_token1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, + STATE(684), 1, + sym__expression, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [10571] = 27, + STATE(413), 2, + sym_comment, + sym_include, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(817), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(825), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [10985] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(670), 1, + STATE(685), 1, sym__expression, - STATE(782), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(832), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(394), 2, + STATE(414), 2, sym_comment, sym_include, - STATE(781), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49781,69 +53795,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10680] = 27, + [11094] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(663), 1, + STATE(690), 1, sym__expression, - STATE(782), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(832), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(395), 2, + STATE(415), 2, sym_comment, sym_include, - STATE(781), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49863,69 +53877,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10789] = 27, + [11203] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, - aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(668), 1, - sym__expression, - STATE(782), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(808), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(396), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(416), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -49945,69 +53959,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [10898] = 27, + [11312] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(756), 1, + STATE(603), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(397), 2, + STATE(417), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50027,69 +54041,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11007] = 27, + [11421] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, - sym_identifier, - ACTIONS(798), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(140), 1, anon_sym_LPAREN, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, ACTIONS(812), 1, - aux_sym_unary_expression_token1, + sym_identifier, ACTIONS(814), 1, - aux_sym_unary_expression_token2, + aux_sym_unary_expression_token1, ACTIONS(816), 1, - aux_sym_ambiguous_expression_token1, + aux_sym_unary_expression_token2, ACTIONS(818), 1, - aux_sym_current_changed_expression_token1, + aux_sym_ambiguous_expression_token1, ACTIONS(820), 1, - aux_sym_locked_expression_token1, + aux_sym_current_changed_expression_token1, ACTIONS(822), 1, - aux_sym_input_expression_token1, + aux_sym_locked_expression_token1, ACTIONS(824), 1, - aux_sym_scope_tuning_token1, - ACTIONS(826), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, - aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(667), 1, - sym__expression, - STATE(782), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(751), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(398), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(418), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50109,69 +54123,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11116] = 27, + [11530] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, + aux_sym_scope_tuning_token1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(696), 1, + STATE(610), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(399), 2, + STATE(419), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50191,69 +54205,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11225] = 27, + [11639] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(666), 1, + STATE(692), 1, sym__expression, - STATE(782), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(832), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(400), 2, + STATE(420), 2, sym_comment, sym_include, - STATE(781), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50273,69 +54287,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11334] = 27, + [11748] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(715), 1, + STATE(845), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(401), 2, + STATE(421), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50355,69 +54369,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11443] = 27, + [11857] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(544), 1, + STATE(599), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(402), 2, + STATE(422), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50437,128 +54451,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11552] = 4, + [11966] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(403), 2, - sym_comment, - sym_include, - ACTIONS(448), 50, - anon_sym_SLASH, + ACTIONS(128), 1, anon_sym_LBRACE, - sym_identifier, - sym__terminator, + ACTIONS(130), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(134), 1, sym__integer_literal, + ACTIONS(136), 1, anon_sym_DQUOTE, + ACTIONS(138), 1, anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_object_access_token1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [11615] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(796), 1, - sym_identifier, - ACTIONS(798), 1, - anon_sym_LBRACE, - ACTIONS(800), 1, - sym_null_expression, - ACTIONS(804), 1, - sym__integer_literal, - ACTIONS(806), 1, - anon_sym_DQUOTE, - ACTIONS(808), 1, - anon_sym_SQUOTE, - ACTIONS(810), 1, - anon_sym_LPAREN, + ACTIONS(194), 1, + aux_sym_input_expression_token1, ACTIONS(812), 1, - aux_sym_unary_expression_token1, + sym_identifier, ACTIONS(814), 1, - aux_sym_unary_expression_token2, + aux_sym_unary_expression_token1, ACTIONS(816), 1, - aux_sym_ambiguous_expression_token1, + aux_sym_unary_expression_token2, ACTIONS(818), 1, - aux_sym_current_changed_expression_token1, + aux_sym_ambiguous_expression_token1, ACTIONS(820), 1, - aux_sym_locked_expression_token1, + aux_sym_current_changed_expression_token1, ACTIONS(822), 1, - aux_sym_input_expression_token1, + aux_sym_locked_expression_token1, ACTIONS(824), 1, - aux_sym_scope_tuning_token1, - ACTIONS(826), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, - aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(662), 1, - sym__expression, - STATE(782), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(832), 2, + STATE(753), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(404), 2, - sym_comment, - sym_include, - STATE(781), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + STATE(423), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50578,69 +54533,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11724] = 27, + [12075] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(757), 1, + STATE(754), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(405), 2, + STATE(424), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50660,69 +54615,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11833] = 27, + [12184] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(768), 1, + STATE(765), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(406), 2, + STATE(425), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50742,233 +54697,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [11942] = 27, + [12293] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(753), 1, - sym__expression, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(407), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [12051] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, - aux_sym_unary_expression_token2, - ACTIONS(161), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, - aux_sym_locked_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, - aux_sym_if_statement_token1, - ACTIONS(183), 1, - aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(580), 1, - sym__expression, - ACTIONS(143), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(408), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [12160] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, + ACTIONS(812), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(586), 1, + STATE(755), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(409), 2, + STATE(426), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -50988,15 +54779,15 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12269] = 4, + [12402] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(410), 2, + STATE(427), 2, sym_comment, sym_include, - ACTIONS(633), 50, + ACTIONS(432), 50, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -51047,69 +54838,69 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [12332] = 27, + [12465] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(680), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(846), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(411), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(428), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51129,129 +54920,151 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12441] = 5, + [12574] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(639), 1, - anon_sym_LPAREN, - STATE(412), 2, - sym_comment, - sym_include, - ACTIONS(611), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(828), 1, sym_identifier, - sym__terminator, + ACTIONS(830), 1, + anon_sym_LBRACE, + ACTIONS(832), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(836), 1, sym__integer_literal, + ACTIONS(838), 1, anon_sym_DQUOTE, + ACTIONS(840), 1, anon_sym_SQUOTE, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(842), 1, + anon_sym_LPAREN, + ACTIONS(844), 1, aux_sym_unary_expression_token1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - aux_sym_object_access_token1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, + STATE(742), 1, + sym__expression, + STATE(929), 1, + sym__decimal_literal, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [12506] = 27, + STATE(429), 2, + sym_comment, + sym_include, + STATE(930), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(834), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(915), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(923), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [12683] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(597), 1, + STATE(728), 1, sym__expression, - STATE(640), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(778), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(413), 2, + STATE(430), 2, sym_comment, sym_include, - STATE(636), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51271,69 +55084,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12615] = 27, + [12792] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(606), 1, + STATE(624), 1, sym__expression, - STATE(640), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(778), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(414), 2, + STATE(431), 2, sym_comment, sym_include, - STATE(636), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51353,69 +55166,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12724] = 27, + [12901] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(611), 1, + STATE(853), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(415), 2, + STATE(432), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51435,69 +55248,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12833] = 27, + [13010] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(584), 1, + STATE(851), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(416), 2, + STATE(433), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51517,69 +55330,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [12942] = 27, + [13119] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(684), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(850), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(417), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(434), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51599,69 +55412,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13051] = 27, + [13228] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, + ACTIONS(812), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(571), 1, + STATE(747), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(418), 2, + STATE(435), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51681,69 +55494,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13160] = 27, + [13337] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(688), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(847), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(419), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(436), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51763,69 +55576,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13269] = 27, + [13446] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(609), 1, + STATE(626), 1, sym__expression, - STATE(640), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(778), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(420), 2, + STATE(437), 2, sym_comment, sym_include, - STATE(636), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51845,69 +55658,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13378] = 27, + [13555] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(578), 1, + STATE(843), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(421), 2, + STATE(438), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -51927,69 +55740,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13487] = 27, + [13664] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(724), 1, + STATE(842), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(422), 2, + STATE(439), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52009,69 +55822,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13596] = 27, + [13773] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, + ACTIONS(812), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(579), 1, + STATE(748), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(423), 2, + STATE(440), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52091,69 +55904,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13705] = 27, + [13882] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(589), 1, + STATE(852), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(424), 2, + STATE(441), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52173,69 +55986,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13814] = 27, + [13991] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, - anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - STATE(686), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(364), 1, sym__expression, - STATE(804), 1, + STATE(573), 1, sym__decimal_literal, - ACTIONS(884), 2, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(425), 2, + STATE(442), 2, sym_comment, sym_include, - STATE(809), 2, + STATE(547), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52255,69 +56068,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [13923] = 27, + [14100] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(697), 1, + STATE(781), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(426), 2, + STATE(443), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52337,69 +56150,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14032] = 27, + [14209] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(587), 1, + STATE(782), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(427), 2, + STATE(444), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52419,69 +56232,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14141] = 27, + [14318] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(613), 1, + STATE(841), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(428), 2, + STATE(445), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52501,69 +56314,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14250] = 27, + [14427] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(828), 1, + sym_identifier, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(854), 1, + aux_sym_input_expression_token1, + ACTIONS(856), 1, + aux_sym_scope_tuning_token1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(860), 1, + aux_sym_can_find_expression_token1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(583), 1, + STATE(740), 1, sym__expression, - ACTIONS(143), 2, + STATE(929), 1, + sym__decimal_literal, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(429), 2, + STATE(446), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(930), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52583,69 +56396,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14359] = 27, + [14536] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(828), 1, + sym_identifier, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(854), 1, + aux_sym_input_expression_token1, + ACTIONS(856), 1, + aux_sym_scope_tuning_token1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(860), 1, + aux_sym_can_find_expression_token1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(592), 1, + STATE(739), 1, sym__expression, - ACTIONS(143), 2, + STATE(929), 1, + sym__decimal_literal, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(430), 2, + STATE(447), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(930), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52665,69 +56478,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14468] = 27, + [14645] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(774), 1, + sym_identifier, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(800), 1, + aux_sym_input_expression_token1, + ACTIONS(802), 1, + aux_sym_scope_tuning_token1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(806), 1, + aux_sym_can_find_expression_token1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(577), 1, + STATE(625), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(431), 2, + STATE(448), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52747,69 +56560,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14577] = 27, + [14754] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - STATE(607), 1, + STATE(621), 1, sym__expression, - STATE(640), 1, + STATE(819), 1, sym__decimal_literal, - ACTIONS(778), 2, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(432), 2, + STATE(449), 2, sym_comment, sym_include, - STATE(636), 2, + STATE(818), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52829,69 +56642,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14686] = 27, + [14863] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(582), 1, + STATE(657), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(433), 2, + STATE(450), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52911,69 +56724,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14795] = 27, + [14972] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(759), 1, + STATE(756), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(434), 2, + STATE(451), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -52993,69 +56806,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [14904] = 27, + [15081] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(346), 1, - sym__expression, - STATE(518), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(807), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(435), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(452), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53075,69 +56888,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15013] = 27, + [15190] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(600), 1, - sym__expression, - STATE(640), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(805), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(436), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(453), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53157,69 +56970,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15122] = 27, + [15299] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(598), 1, - sym__expression, - STATE(640), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(826), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(437), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(454), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53239,151 +57052,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15231] = 27, + [15408] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(603), 1, - sym__expression, - STATE(640), 1, - sym__decimal_literal, - ACTIONS(778), 2, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - STATE(438), 2, - sym_comment, - sym_include, - STATE(636), 2, - sym_double_quoted_string, - sym_single_quoted_string, - ACTIONS(748), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(634), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(650), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [15340] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, - aux_sym_unary_expression_token1, - ACTIONS(784), 1, - aux_sym_unary_expression_token2, - ACTIONS(786), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, - aux_sym_locked_expression_token1, - ACTIONS(792), 1, - aux_sym_if_statement_token1, - ACTIONS(794), 1, - aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(701), 1, + STATE(779), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(439), 2, + STATE(455), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53403,69 +57134,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15449] = 27, + [15517] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(780), 1, + ACTIONS(812), 1, sym_identifier, - ACTIONS(782), 1, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(708), 1, + STATE(757), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(440), 2, + STATE(456), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53485,69 +57216,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15558] = 27, + [15626] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(604), 1, - sym__expression, - STATE(640), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(799), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(441), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(457), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53567,69 +57298,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15667] = 27, + [15735] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(698), 1, + STATE(803), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(442), 2, + STATE(458), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53649,69 +57380,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15776] = 27, + [15844] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(543), 1, + STATE(816), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(443), 2, + STATE(459), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53731,69 +57462,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15885] = 27, + [15953] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(685), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(832), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(444), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(460), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53813,69 +57544,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [15994] = 27, + [16062] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(548), 1, + STATE(837), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(445), 2, + STATE(461), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53895,69 +57626,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16103] = 27, + [16171] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(570), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(355), 1, sym__expression, - ACTIONS(143), 2, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(446), 2, + STATE(462), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -53977,69 +57708,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16212] = 27, + [16280] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(576), 1, + STATE(776), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(447), 2, + STATE(463), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54059,69 +57790,129 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16321] = 27, + [16389] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(866), 1, + anon_sym_NO_DASHERROR, + STATE(464), 2, + sym_comment, + sym_include, + ACTIONS(540), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [16454] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(574), 1, + STATE(631), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(448), 2, + STATE(465), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54141,69 +57932,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16430] = 27, + [16563] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(678), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(800), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(449), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(466), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54223,69 +58014,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16539] = 27, + [16672] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(573), 1, + STATE(612), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(450), 2, + STATE(467), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54305,69 +58096,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16648] = 27, + [16781] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, - sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, - aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, - aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - STATE(679), 1, - sym__expression, - STATE(804), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(758), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(451), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(468), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54387,69 +58178,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16757] = 27, + [16890] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(755), 1, + STATE(838), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(452), 2, + STATE(469), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54469,69 +58260,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16866] = 27, + [16999] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(682), 1, + STATE(729), 1, sym__expression, - STATE(804), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(884), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(453), 2, + STATE(470), 2, sym_comment, sym_include, - STATE(809), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54551,69 +58342,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [16975] = 27, + [17108] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(812), 1, + sym_identifier, + ACTIONS(814), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(816), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(818), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(820), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(822), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(824), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(826), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(886), 1, - sym_identifier, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(747), 1, + STATE(761), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(454), 2, + STATE(471), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54633,69 +58424,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17084] = 27, + [17217] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(854), 1, + aux_sym_input_expression_token1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(546), 1, + STATE(730), 1, sym__expression, - ACTIONS(143), 2, + STATE(929), 1, + sym__decimal_literal, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(455), 2, + STATE(472), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(930), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54715,69 +58506,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17193] = 27, + [17326] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, + aux_sym_scope_tuning_token1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(731), 1, + STATE(615), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(456), 2, + STATE(473), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54797,129 +58588,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17302] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(387), 1, - sym__namedot, - STATE(457), 2, - sym_comment, - sym_include, - ACTIONS(385), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [17367] = 27, + [17435] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(796), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(798), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(800), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(804), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(806), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(808), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(810), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(812), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(814), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(816), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(818), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(820), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(822), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(824), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(826), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(828), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(830), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(669), 1, + STATE(720), 1, sym__expression, - STATE(782), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(832), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(458), 2, + STATE(474), 2, sym_comment, sym_include, - STATE(781), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(802), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(780), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(791), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -54939,69 +58670,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17476] = 27, + [17544] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(545), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(362), 1, sym__expression, - ACTIONS(143), 2, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(459), 2, + STATE(475), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55021,69 +58752,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17585] = 27, + [17653] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(842), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - STATE(683), 1, + STATE(725), 1, sym__expression, - STATE(804), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(884), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(460), 2, + STATE(476), 2, sym_comment, sym_include, - STATE(809), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55103,69 +58834,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17694] = 27, + [17762] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(700), 1, + STATE(822), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(461), 2, + STATE(477), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55185,69 +58916,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17803] = 27, + [17871] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, - aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - STATE(601), 1, - sym__expression, - STATE(640), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(617), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(462), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(478), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55267,69 +58998,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [17912] = 27, + [17980] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(868), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(870), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(872), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(876), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(878), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(880), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(882), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(884), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(894), 1, + aux_sym_input_expression_token1, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(898), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(744), 1, + STATE(713), 1, sym__expression, - ACTIONS(143), 2, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(463), 2, + STATE(479), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(890), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(873), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55349,129 +59080,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18021] = 5, + [18089] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(890), 1, - anon_sym_NO_DASHERROR, - STATE(464), 2, - sym_comment, - sym_include, - ACTIONS(888), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(828), 1, sym_identifier, - sym__terminator, + ACTIONS(830), 1, + anon_sym_LBRACE, + ACTIONS(832), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(836), 1, sym__integer_literal, + ACTIONS(838), 1, anon_sym_DQUOTE, + ACTIONS(840), 1, anon_sym_SQUOTE, + ACTIONS(842), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(844), 1, aux_sym_unary_expression_token1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, + ACTIONS(858), 1, aux_sym_if_statement_token1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [18086] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, - aux_sym_unary_expression_token1, - ACTIONS(784), 1, - aux_sym_unary_expression_token2, - ACTIONS(786), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, - aux_sym_locked_expression_token1, - ACTIONS(792), 1, - aux_sym_if_statement_token1, - ACTIONS(794), 1, - aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(707), 1, + STATE(727), 1, sym__expression, - ACTIONS(143), 2, + STATE(929), 1, + sym__decimal_literal, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(465), 2, + STATE(480), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(930), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55491,69 +59162,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18195] = 27, + [18198] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(689), 1, + STATE(840), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(466), 2, + STATE(481), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55573,69 +59244,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18304] = 27, + [18307] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(728), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(356), 1, sym__expression, - ACTIONS(143), 2, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(467), 2, + STATE(482), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55655,69 +59326,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18413] = 27, + [18416] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, + ACTIONS(671), 1, anon_sym_LPAREN, - STATE(348), 1, + STATE(354), 1, sym__expression, - STATE(518), 1, + STATE(573), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(468), 2, + STATE(483), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(547), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55737,69 +59408,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18522] = 27, + [18525] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(547), 1, + STATE(602), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(469), 2, + STATE(484), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55819,151 +59490,129 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18631] = 27, + [18634] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(908), 1, + anon_sym_NO_DASHERROR, + STATE(485), 2, + sym_comment, + sym_include, + ACTIONS(906), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(784), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + aux_sym_can_find_expression_token1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(706), 1, - sym__expression, - ACTIONS(143), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(470), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [18740] = 27, + [18699] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, - anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - STATE(687), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(370), 1, sym__expression, - STATE(804), 1, + STATE(573), 1, sym__decimal_literal, - ACTIONS(884), 2, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(471), 2, + STATE(486), 2, sym_comment, sym_include, - STATE(809), 2, + STATE(547), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -55983,69 +59632,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18849] = 27, + [18808] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, - aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(337), 1, - sym__expression, - STATE(518), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(611), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(472), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(487), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56065,69 +59714,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [18958] = 27, + [18917] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + ACTIONS(910), 1, + sym_identifier, + STATE(301), 1, sym__decimal_literal, - STATE(714), 1, + STATE(812), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(473), 2, + STATE(488), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56147,69 +59796,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19067] = 27, + [19026] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(735), 1, + STATE(806), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(474), 2, + STATE(489), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56229,69 +59878,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19176] = 27, + [19135] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(340), 1, - sym__expression, - STATE(518), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(801), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(475), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(490), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56311,69 +59960,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19285] = 27, + [19244] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(742), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(744), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(746), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(750), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(752), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(754), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(756), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(758), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(760), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(762), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(764), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(766), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(768), 1, - aux_sym_input_expression_token1, - ACTIONS(770), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(772), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(774), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(776), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(599), 1, - sym__expression, - STATE(640), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(778), 2, + STATE(839), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(476), 2, - sym_comment, - sym_include, - STATE(636), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(748), 4, + STATE(491), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(634), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(650), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56393,69 +60042,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19394] = 27, + [19353] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(727), 1, + STATE(844), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(477), 2, + STATE(492), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56475,69 +60124,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19503] = 27, + [19462] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(912), 1, + sym_identifier, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(784), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(786), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(788), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(790), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(792), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, + aux_sym_scope_tuning_token1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(794), 1, + ACTIONS(944), 1, + aux_sym_can_find_expression_token1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(770), 1, + STATE(606), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(478), 2, + STATE(493), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56557,69 +60206,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19612] = 27, + [19571] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(676), 1, + STATE(584), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(479), 2, + STATE(494), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56639,69 +60288,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19721] = 27, + [19680] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(754), 1, + STATE(849), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(480), 2, + STATE(495), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56721,69 +60370,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19830] = 27, + [19789] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(800), 1, + aux_sym_input_expression_token1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(616), 1, + STATE(677), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(481), 2, + STATE(496), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56803,69 +60452,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [19939] = 27, + [19898] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(767), 1, + STATE(848), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(482), 2, + STATE(497), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56885,69 +60534,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20048] = 27, + [20007] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(581), 1, + STATE(749), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(483), 2, + STATE(498), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -56967,69 +60616,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20157] = 27, + [20116] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(732), 1, + STATE(583), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(484), 2, + STATE(499), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57049,128 +60698,233 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20266] = 4, + [20225] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(485), 2, - sym_comment, - sym_include, - ACTIONS(460), 50, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(558), 1, sym_identifier, - sym__terminator, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, sym_null_expression, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(570), 1, + anon_sym_DQUOTE, + ACTIONS(572), 1, + anon_sym_SQUOTE, + ACTIONS(576), 1, + aux_sym_unary_expression_token1, + ACTIONS(578), 1, + aux_sym_unary_expression_token2, + ACTIONS(580), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, + aux_sym_locked_expression_token1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(590), 1, + aux_sym_scope_tuning_token1, + ACTIONS(592), 1, + aux_sym_if_statement_token1, + ACTIONS(596), 1, + aux_sym_can_find_expression_token1, + ACTIONS(598), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(358), 1, + sym__expression, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(500), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [20334] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(558), 1, + sym_identifier, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, + sym_null_expression, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - aux_sym_object_access_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(359), 1, + sym__expression, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [20329] = 27, + STATE(501), 2, + sym_comment, + sym_include, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(574), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(563), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [20443] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(558), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(560), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(564), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(568), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(570), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(572), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(576), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(586), 1, + aux_sym_input_expression_token1, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(592), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(718), 1, + ACTIONS(671), 1, + anon_sym_LPAREN, + STATE(360), 1, sym__expression, - ACTIONS(143), 2, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(486), 2, + STATE(502), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57190,69 +60944,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20438] = 27, + [20552] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(765), 1, + STATE(582), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(487), 2, + STATE(503), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57272,69 +61026,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20547] = 27, + [20661] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(726), 1, + STATE(581), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(488), 2, + STATE(504), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57354,69 +61108,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20656] = 27, + [20770] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(572), 1, + STATE(578), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(489), 2, + STATE(505), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57436,69 +61190,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20765] = 27, + [20879] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(610), 1, + STATE(575), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(490), 2, + STATE(506), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57518,69 +61272,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20874] = 27, + [20988] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(848), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(850), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(852), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(856), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(858), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(860), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(862), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(864), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(866), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(868), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(870), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(872), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(874), 1, - aux_sym_input_expression_token1, - ACTIONS(876), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(878), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(880), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(882), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(681), 1, - sym__expression, - STATE(804), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(884), 2, + STATE(775), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(491), 2, - sym_comment, - sym_include, - STATE(809), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(854), 4, + STATE(507), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(808), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(821), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57600,129 +61354,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [20983] = 5, + [21097] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(892), 1, - sym__namedot, - STATE(492), 2, - sym_comment, - sym_include, - ACTIONS(412), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(558), 1, sym_identifier, - sym__terminator, + ACTIONS(560), 1, + anon_sym_LBRACE, + ACTIONS(564), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(568), 1, sym__integer_literal, + ACTIONS(570), 1, anon_sym_DQUOTE, + ACTIONS(572), 1, anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(576), 1, aux_sym_unary_expression_token1, + ACTIONS(578), 1, aux_sym_unary_expression_token2, + ACTIONS(580), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(582), 1, aux_sym_current_changed_expression_token1, + ACTIONS(584), 1, aux_sym_locked_expression_token1, + ACTIONS(586), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(590), 1, aux_sym_scope_tuning_token1, + ACTIONS(592), 1, aux_sym_if_statement_token1, + ACTIONS(596), 1, aux_sym_can_find_expression_token1, + ACTIONS(598), 1, aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [21048] = 27, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, - anon_sym_LBRACE, - ACTIONS(105), 1, - sym_null_expression, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(671), 1, anon_sym_LPAREN, - ACTIONS(119), 1, - aux_sym_unary_expression_token1, - ACTIONS(121), 1, - aux_sym_unary_expression_token2, - ACTIONS(123), 1, - aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, - aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, - aux_sym_locked_expression_token1, - ACTIONS(131), 1, - aux_sym_scope_tuning_token1, - ACTIONS(135), 1, - aux_sym_if_statement_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(141), 1, - aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(764), 1, + STATE(361), 1, sym__expression, - ACTIONS(143), 2, + STATE(573), 1, + sym__decimal_literal, + ACTIONS(600), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(493), 2, + STATE(508), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(547), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(566), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(574), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(563), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57742,69 +61436,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21157] = 27, + [21206] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(842), 1, + anon_sym_LPAREN, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(338), 1, + STATE(735), 1, sym__expression, - STATE(518), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(494), 2, + STATE(509), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57824,69 +61518,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21266] = 27, + [21315] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(169), 1, - aux_sym_scope_tuning_token1, - ACTIONS(780), 1, - sym_identifier, - ACTIONS(782), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(836), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(838), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(840), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(842), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(844), 1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(846), 1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - STATE(575), 1, + STATE(855), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(495), 2, + STATE(510), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57906,69 +61600,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21375] = 27, + [21424] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(828), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(830), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(832), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(836), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(838), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(840), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(842), 1, + anon_sym_LPAREN, + ACTIONS(844), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(846), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(848), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(850), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(852), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(854), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(856), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(858), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(860), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(862), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(352), 1, + STATE(737), 1, sym__expression, - STATE(518), 1, + STATE(929), 1, sym__decimal_literal, - ACTIONS(586), 2, + ACTIONS(864), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(496), 2, + STATE(511), 2, sym_comment, sym_include, - STATE(520), 2, + STATE(930), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + ACTIONS(834), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(915), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(923), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -57988,69 +61682,131 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21484] = 27, + [21533] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(950), 1, + anon_sym_NO_DASHERROR, + STATE(512), 2, + sym_comment, + sym_include, + ACTIONS(540), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(542), 45, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [21602] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, - aux_sym_input_expression_token1, - ACTIONS(576), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(350), 1, - sym__expression, - STATE(518), 1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(835), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(497), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(513), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58070,69 +61826,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21593] = 27, + [21711] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(126), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + STATE(301), 1, sym__decimal_literal, - STATE(725), 1, + STATE(731), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(498), 2, + STATE(514), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58152,69 +61908,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21702] = 27, + [21820] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(140), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(144), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(146), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(148), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(150), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(152), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(156), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(160), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(162), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(166), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - STATE(284), 1, + ACTIONS(952), 1, + sym_identifier, + STATE(301), 1, sym__decimal_literal, - STATE(550), 1, + STATE(827), 1, sym__expression, - ACTIONS(143), 2, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - STATE(499), 2, + STATE(515), 2, sym_comment, sym_include, - ACTIONS(107), 4, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58234,69 +61990,131 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21811] = 27, + [21929] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(956), 1, + anon_sym_NO_DASHERROR, + STATE(516), 2, + sym_comment, + sym_include, + ACTIONS(906), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(954), 45, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + anon_sym_COLON, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [21998] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(774), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(776), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(778), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(782), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(784), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(786), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(788), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(790), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(800), 1, + aux_sym_input_expression_token1, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(804), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(730), 1, + STATE(623), 1, sym__expression, - ACTIONS(143), 2, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(500), 2, + STATE(517), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(817), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(825), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58316,69 +62134,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [21920] = 27, + [22107] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(629), 1, + STATE(600), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(501), 2, + STATE(518), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58398,69 +62216,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22029] = 27, + [22216] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, + ACTIONS(938), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(944), 1, + aux_sym_can_find_expression_token1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(588), 1, + STATE(609), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(502), 2, + STATE(519), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58480,69 +62298,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22138] = 27, + [22325] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(544), 1, - sym_identifier, - ACTIONS(546), 1, + ACTIONS(128), 1, anon_sym_LBRACE, - ACTIONS(550), 1, + ACTIONS(130), 1, sym_null_expression, - ACTIONS(554), 1, + ACTIONS(134), 1, sym__integer_literal, - ACTIONS(556), 1, + ACTIONS(136), 1, anon_sym_DQUOTE, - ACTIONS(558), 1, + ACTIONS(138), 1, anon_sym_SQUOTE, - ACTIONS(562), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(756), 1, + sym_identifier, + ACTIONS(758), 1, aux_sym_unary_expression_token1, - ACTIONS(564), 1, + ACTIONS(760), 1, aux_sym_unary_expression_token2, - ACTIONS(566), 1, + ACTIONS(762), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(568), 1, + ACTIONS(764), 1, aux_sym_current_changed_expression_token1, - ACTIONS(570), 1, + ACTIONS(766), 1, aux_sym_locked_expression_token1, - ACTIONS(572), 1, + ACTIONS(768), 1, aux_sym_input_expression_token1, - ACTIONS(576), 1, - aux_sym_scope_tuning_token1, - ACTIONS(578), 1, + ACTIONS(770), 1, aux_sym_if_statement_token1, - ACTIONS(582), 1, - aux_sym_can_find_expression_token1, - ACTIONS(584), 1, + ACTIONS(772), 1, aux_sym_accumulate_expression_token1, - ACTIONS(657), 1, - anon_sym_LPAREN, - STATE(339), 1, - sym__expression, - STATE(518), 1, + STATE(301), 1, sym__decimal_literal, - ACTIONS(586), 2, + STATE(681), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(503), 2, - sym_comment, - sym_include, - STATE(520), 2, + STATE(296), 2, sym_double_quoted_string, sym_single_quoted_string, - ACTIONS(552), 4, + STATE(520), 2, + sym_comment, + sym_include, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(540), 4, + STATE(305), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(534), 19, + STATE(308), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58562,69 +62380,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22247] = 27, + [22434] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(743), 1, + STATE(608), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(504), 2, + STATE(521), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58644,69 +62462,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22356] = 27, + [22543] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(868), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(870), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(872), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(876), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(878), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(880), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(882), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(884), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(894), 1, + aux_sym_input_expression_token1, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(898), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(769), 1, + STATE(704), 1, sym__expression, - ACTIONS(143), 2, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(505), 2, + STATE(522), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(890), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(873), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58726,69 +62544,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22465] = 27, + [22652] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(868), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(870), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(872), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(876), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(878), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(880), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(882), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(884), 1, aux_sym_unary_expression_token1, - ACTIONS(137), 1, - aux_sym_can_find_expression_token1, - ACTIONS(159), 1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, - ACTIONS(161), 1, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(163), 1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, - ACTIONS(165), 1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, - ACTIONS(167), 1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - ACTIONS(169), 1, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, - ACTIONS(171), 1, + ACTIONS(898), 1, aux_sym_if_statement_token1, - ACTIONS(183), 1, + ACTIONS(900), 1, + aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(590), 1, + STATE(711), 1, sym__expression, - ACTIONS(143), 2, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(506), 2, + STATE(523), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(890), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(873), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58808,69 +62626,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22574] = 27, + [22761] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(103), 1, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(872), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(876), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(878), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(880), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(882), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(884), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(894), 1, + aux_sym_input_expression_token1, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(898), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - ACTIONS(894), 1, - sym_identifier, - STATE(284), 1, - sym__decimal_literal, - STATE(720), 1, + STATE(707), 1, sym__expression, - ACTIONS(143), 2, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(507), 2, + STATE(524), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(890), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(873), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -58890,233 +62708,188 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [22683] = 27, + [22870] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + STATE(525), 2, + sym_comment, + sym_include, + ACTIONS(657), 50, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(121), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + aux_sym_object_access_token1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(739), 1, - sym__expression, - ACTIONS(143), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(508), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [22792] = 27, + [22933] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, - sym_identifier, - ACTIONS(103), 1, + ACTIONS(649), 1, + anon_sym_LPAREN, + STATE(526), 2, + sym_comment, + sym_include, + ACTIONS(661), 49, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(105), 1, + sym_identifier, + sym__terminator, sym_null_expression, - ACTIONS(109), 1, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, sym__integer_literal, - ACTIONS(111), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(119), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, aux_sym_unary_expression_token1, - ACTIONS(121), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + aux_sym_object_access_token1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(549), 1, - sym__expression, - ACTIONS(143), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(509), 2, - sym_comment, - sym_include, - ACTIONS(107), 4, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - STATE(312), 4, - sym_logical_expression, - sym_additive_expression, - sym_multiplicative_expression, - sym_comparison_expression, - STATE(310), 19, - sym_constant, - sym_qualified_name, - sym_boolean_literal, - sym_number_literal, - sym__string_literal, - sym_parenthesized_expression, - sym_unary_expression, - sym_ambiguous_expression, - sym_current_changed_expression, - sym_locked_expression, - sym_input_expression, - sym__binary_expression, - sym_function_call, - sym_ternary_expression, - sym_new_expression, - sym_object_access, - sym_can_find_expression, - sym_accumulate_expression, - sym_available_expression, - [22901] = 27, + [22998] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(761), 1, + STATE(614), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(510), 2, + STATE(527), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -59136,69 +62909,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [23010] = 27, + [23107] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(716), 1, + STATE(601), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(511), 2, + STATE(528), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -59218,69 +62991,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [23119] = 27, + [23216] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(675), 1, + STATE(618), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(512), 2, + STATE(529), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -59300,69 +63073,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [23228] = 27, + [23325] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(712), 1, + STATE(619), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(513), 2, + STATE(530), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -59382,69 +63155,69 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [23337] = 27, + [23434] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(101), 1, + ACTIONS(912), 1, sym_identifier, - ACTIONS(103), 1, + ACTIONS(914), 1, anon_sym_LBRACE, - ACTIONS(105), 1, + ACTIONS(916), 1, sym_null_expression, - ACTIONS(109), 1, + ACTIONS(920), 1, sym__integer_literal, - ACTIONS(111), 1, + ACTIONS(922), 1, anon_sym_DQUOTE, - ACTIONS(113), 1, + ACTIONS(924), 1, anon_sym_SQUOTE, - ACTIONS(115), 1, + ACTIONS(926), 1, anon_sym_LPAREN, - ACTIONS(119), 1, + ACTIONS(928), 1, aux_sym_unary_expression_token1, - ACTIONS(121), 1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, - ACTIONS(123), 1, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, - ACTIONS(125), 1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, - ACTIONS(127), 1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, - ACTIONS(131), 1, + ACTIONS(938), 1, + aux_sym_input_expression_token1, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, - ACTIONS(135), 1, + ACTIONS(942), 1, aux_sym_if_statement_token1, - ACTIONS(137), 1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, - ACTIONS(141), 1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, - ACTIONS(167), 1, - aux_sym_input_expression_token1, - STATE(284), 1, - sym__decimal_literal, - STATE(717), 1, + STATE(607), 1, sym__expression, - ACTIONS(143), 2, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(514), 2, + STATE(531), 2, sym_comment, sym_include, - ACTIONS(107), 4, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, - STATE(312), 4, + STATE(652), 4, sym_logical_expression, sym_additive_expression, sym_multiplicative_expression, sym_comparison_expression, - STATE(310), 19, + STATE(648), 19, sym_constant, sym_qualified_name, sym_boolean_literal, @@ -59464,15 +63237,17 @@ static const uint16_t ts_small_parse_table[] = { sym_can_find_expression, sym_accumulate_expression, sym_available_expression, - [23446] = 4, + [23543] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(515), 2, + ACTIONS(958), 1, + sym__namedot, + STATE(532), 2, sym_comment, sym_include, - ACTIONS(508), 49, + ACTIONS(422), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -59522,537 +63297,837 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23508] = 4, + [23608] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(516), 2, - sym_comment, - sym_include, - ACTIONS(422), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(912), 1, sym_identifier, - sym__terminator, + ACTIONS(914), 1, + anon_sym_LBRACE, + ACTIONS(916), 1, sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, + ACTIONS(920), 1, sym__integer_literal, + ACTIONS(922), 1, anon_sym_DQUOTE, + ACTIONS(924), 1, anon_sym_SQUOTE, + ACTIONS(926), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(928), 1, aux_sym_unary_expression_token1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, + ACTIONS(938), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, + ACTIONS(942), 1, aux_sym_if_statement_token1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, + STATE(620), 1, + sym__expression, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23570] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(517), 2, + STATE(533), 2, sym_comment, sym_include, - ACTIONS(540), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(652), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(648), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [23717] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, sym__integer_literal, + ACTIONS(136), 1, anon_sym_DQUOTE, + ACTIONS(138), 1, anon_sym_SQUOTE, + ACTIONS(140), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(144), 1, aux_sym_unary_expression_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, aux_sym_unary_expression_token2, + ACTIONS(188), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(190), 1, aux_sym_current_changed_expression_token1, + ACTIONS(192), 1, aux_sym_locked_expression_token1, + ACTIONS(194), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(196), 1, aux_sym_scope_tuning_token1, + ACTIONS(198), 1, aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, + ACTIONS(210), 1, aux_sym_accumulate_expression_token1, + STATE(301), 1, + sym__decimal_literal, + STATE(605), 1, + sym__expression, + ACTIONS(168), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23632] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(518), 2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(534), 2, sym_comment, sym_include, - ACTIONS(412), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + ACTIONS(132), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [23826] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(715), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23694] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(519), 2, + STATE(535), 2, sym_comment, sym_include, - ACTIONS(500), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [23935] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(710), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23756] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(520), 2, + STATE(536), 2, sym_comment, sym_include, - ACTIONS(408), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24044] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(700), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23818] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(521), 2, + STATE(537), 2, sym_comment, sym_include, - ACTIONS(400), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24153] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(708), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23880] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(522), 2, + STATE(538), 2, sym_comment, sym_include, - ACTIONS(512), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24262] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(705), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [23942] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(523), 2, + STATE(539), 2, sym_comment, sym_include, - ACTIONS(464), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24371] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(774), 1, + sym_identifier, + ACTIONS(776), 1, + anon_sym_LBRACE, + ACTIONS(778), 1, + sym_null_expression, + ACTIONS(782), 1, sym__integer_literal, + ACTIONS(784), 1, anon_sym_DQUOTE, + ACTIONS(786), 1, anon_sym_SQUOTE, + ACTIONS(788), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(790), 1, aux_sym_unary_expression_token1, + ACTIONS(792), 1, aux_sym_unary_expression_token2, + ACTIONS(794), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(796), 1, aux_sym_current_changed_expression_token1, + ACTIONS(798), 1, aux_sym_locked_expression_token1, + ACTIONS(800), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(802), 1, aux_sym_scope_tuning_token1, + ACTIONS(804), 1, aux_sym_if_statement_token1, + ACTIONS(806), 1, aux_sym_can_find_expression_token1, + ACTIONS(808), 1, aux_sym_accumulate_expression_token1, + STATE(622), 1, + sym__expression, + STATE(819), 1, + sym__decimal_literal, + ACTIONS(810), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24004] = 4, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - STATE(524), 2, + STATE(540), 2, sym_comment, sym_include, - ACTIONS(468), 49, - anon_sym_SLASH, - anon_sym_LBRACE, - sym_identifier, - sym__terminator, - sym_null_expression, + STATE(818), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(780), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(817), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(825), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24480] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(912), 1, + sym_identifier, + ACTIONS(914), 1, + anon_sym_LBRACE, + ACTIONS(916), 1, + sym_null_expression, + ACTIONS(920), 1, sym__integer_literal, + ACTIONS(922), 1, anon_sym_DQUOTE, + ACTIONS(924), 1, anon_sym_SQUOTE, + ACTIONS(926), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(928), 1, aux_sym_unary_expression_token1, + ACTIONS(930), 1, aux_sym_unary_expression_token2, + ACTIONS(932), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(934), 1, aux_sym_current_changed_expression_token1, + ACTIONS(936), 1, aux_sym_locked_expression_token1, + ACTIONS(938), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(940), 1, aux_sym_scope_tuning_token1, + ACTIONS(942), 1, aux_sym_if_statement_token1, + ACTIONS(944), 1, aux_sym_can_find_expression_token1, + ACTIONS(946), 1, aux_sym_accumulate_expression_token1, + STATE(613), 1, + sym__expression, + STATE(646), 1, + sym__decimal_literal, + ACTIONS(948), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24066] = 4, + STATE(541), 2, + sym_comment, + sym_include, + STATE(651), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(918), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(652), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(648), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24589] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(525), 2, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(186), 1, + aux_sym_unary_expression_token2, + ACTIONS(188), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(190), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(192), 1, + aux_sym_locked_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + ACTIONS(196), 1, + aux_sym_scope_tuning_token1, + ACTIONS(198), 1, + aux_sym_if_statement_token1, + ACTIONS(210), 1, + aux_sym_accumulate_expression_token1, + STATE(301), 1, + sym__decimal_literal, + STATE(616), 1, + sym__expression, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(542), 2, sym_comment, sym_include, - ACTIONS(418), 49, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24698] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(71), 1, + sym__namedot, + STATE(543), 2, + sym_comment, + sym_include, + ACTIONS(69), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60102,73 +64177,261 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24128] = 4, + [24763] = 27, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(526), 2, + ACTIONS(126), 1, + sym_identifier, + ACTIONS(128), 1, + anon_sym_LBRACE, + ACTIONS(130), 1, + sym_null_expression, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(144), 1, + aux_sym_unary_expression_token1, + ACTIONS(146), 1, + aux_sym_unary_expression_token2, + ACTIONS(148), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(150), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(152), 1, + aux_sym_locked_expression_token1, + ACTIONS(156), 1, + aux_sym_scope_tuning_token1, + ACTIONS(160), 1, + aux_sym_if_statement_token1, + ACTIONS(162), 1, + aux_sym_can_find_expression_token1, + ACTIONS(166), 1, + aux_sym_accumulate_expression_token1, + ACTIONS(194), 1, + aux_sym_input_expression_token1, + STATE(301), 1, + sym__decimal_literal, + STATE(714), 1, + sym__expression, + ACTIONS(168), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(544), 2, sym_comment, sym_include, - ACTIONS(404), 49, - anon_sym_SLASH, - anon_sym_LBRACE, + ACTIONS(132), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(305), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(308), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24872] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, sym_identifier, - sym__terminator, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, sym_null_expression, + ACTIONS(876), 1, + sym__integer_literal, + ACTIONS(878), 1, + anon_sym_DQUOTE, + ACTIONS(880), 1, + anon_sym_SQUOTE, + ACTIONS(882), 1, + anon_sym_LPAREN, + ACTIONS(884), 1, + aux_sym_unary_expression_token1, + ACTIONS(886), 1, + aux_sym_unary_expression_token2, + ACTIONS(888), 1, + aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, + aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, + aux_sym_locked_expression_token1, + ACTIONS(894), 1, + aux_sym_input_expression_token1, + ACTIONS(896), 1, + aux_sym_scope_tuning_token1, + ACTIONS(898), 1, + aux_sym_if_statement_token1, + ACTIONS(900), 1, + aux_sym_can_find_expression_token1, + ACTIONS(902), 1, + aux_sym_accumulate_expression_token1, + STATE(712), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + STATE(545), 2, + sym_comment, + sym_include, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, aux_sym_boolean_literal_token1, aux_sym_boolean_literal_token2, aux_sym_boolean_literal_token3, aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [24981] = 27, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(868), 1, + sym_identifier, + ACTIONS(870), 1, + anon_sym_LBRACE, + ACTIONS(872), 1, + sym_null_expression, + ACTIONS(876), 1, sym__integer_literal, + ACTIONS(878), 1, anon_sym_DQUOTE, + ACTIONS(880), 1, anon_sym_SQUOTE, + ACTIONS(882), 1, anon_sym_LPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(884), 1, aux_sym_unary_expression_token1, + ACTIONS(886), 1, aux_sym_unary_expression_token2, + ACTIONS(888), 1, aux_sym_ambiguous_expression_token1, + ACTIONS(890), 1, aux_sym_current_changed_expression_token1, + ACTIONS(892), 1, aux_sym_locked_expression_token1, + ACTIONS(894), 1, aux_sym_input_expression_token1, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(896), 1, aux_sym_scope_tuning_token1, + ACTIONS(898), 1, aux_sym_if_statement_token1, + ACTIONS(900), 1, aux_sym_can_find_expression_token1, + ACTIONS(902), 1, aux_sym_accumulate_expression_token1, + STATE(706), 1, + sym__expression, + STATE(887), 1, + sym__decimal_literal, + ACTIONS(904), 2, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24190] = 4, + STATE(546), 2, + sym_comment, + sym_include, + STATE(889), 2, + sym_double_quoted_string, + sym_single_quoted_string, + ACTIONS(874), 4, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + STATE(890), 4, + sym_logical_expression, + sym_additive_expression, + sym_multiplicative_expression, + sym_comparison_expression, + STATE(873), 19, + sym_constant, + sym_qualified_name, + sym_boolean_literal, + sym_number_literal, + sym__string_literal, + sym_parenthesized_expression, + sym_unary_expression, + sym_ambiguous_expression, + sym_current_changed_expression, + sym_locked_expression, + sym_input_expression, + sym__binary_expression, + sym_function_call, + sym_ternary_expression, + sym_new_expression, + sym_object_access, + sym_can_find_expression, + sym_accumulate_expression, + sym_available_expression, + [25090] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(527), 2, + STATE(547), 2, sym_comment, sym_include, - ACTIONS(524), 49, + ACTIONS(410), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60218,15 +64481,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24252] = 4, + [25152] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(528), 2, + STATE(548), 2, sym_comment, sym_include, - ACTIONS(504), 49, + ACTIONS(418), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60276,15 +64539,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24314] = 4, + [25214] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(529), 2, + STATE(549), 2, sym_comment, sym_include, - ACTIONS(496), 49, + ACTIONS(428), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60334,15 +64597,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24376] = 4, + [25276] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(530), 2, + STATE(550), 2, sym_comment, sym_include, - ACTIONS(426), 49, + ACTIONS(504), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60392,15 +64655,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24438] = 4, + [25338] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(531), 2, + STATE(551), 2, sym_comment, sym_include, - ACTIONS(396), 49, + ACTIONS(406), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60450,15 +64713,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24500] = 4, + [25400] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(532), 2, + STATE(552), 2, sym_comment, sym_include, - ACTIONS(536), 49, + ACTIONS(402), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60508,15 +64771,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24562] = 4, + [25462] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(533), 2, + STATE(553), 2, sym_comment, sym_include, - ACTIONS(472), 49, + ACTIONS(486), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60566,15 +64829,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24624] = 4, + [25524] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(534), 2, + STATE(554), 2, sym_comment, sym_include, - ACTIONS(484), 49, + ACTIONS(466), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60624,15 +64887,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24686] = 4, + [25586] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(535), 2, + STATE(555), 2, sym_comment, sym_include, - ACTIONS(480), 49, + ACTIONS(532), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60682,15 +64945,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24748] = 4, + [25648] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(536), 2, + STATE(556), 2, sym_comment, sym_include, - ACTIONS(392), 49, + ACTIONS(462), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60740,15 +65003,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24810] = 4, + [25710] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(537), 2, + STATE(557), 2, sym_comment, sym_include, - ACTIONS(516), 49, + ACTIONS(482), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60798,15 +65061,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24872] = 4, + [25772] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(538), 2, + STATE(558), 2, sym_comment, sym_include, - ACTIONS(520), 49, + ACTIONS(414), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60856,15 +65119,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24934] = 4, + [25834] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(539), 2, + STATE(559), 2, sym_comment, sym_include, - ACTIONS(528), 49, + ACTIONS(550), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60914,15 +65177,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [24996] = 4, + [25896] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(540), 2, + STATE(560), 2, sym_comment, sym_include, - ACTIONS(492), 49, + ACTIONS(508), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -60972,15 +65235,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [25058] = 4, + [25958] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(541), 2, + STATE(561), 2, sym_comment, sym_include, - ACTIONS(476), 49, + ACTIONS(544), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -61030,15 +65293,15 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [25120] = 4, + [26020] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(542), 2, + STATE(562), 2, sym_comment, sym_include, - ACTIONS(532), 49, + ACTIONS(490), 49, anon_sym_SLASH, anon_sym_LBRACE, sym_identifier, @@ -61088,47 +65351,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_expression_token1, aux_sym_available_expression_token1, aux_sym_available_expression_token2, - [25182] = 16, - ACTIONS(373), 1, + [26082] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(653), 1, - aux_sym_widget_field_token1, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(543), 2, + STATE(563), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(454), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61139,65 +65403,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(896), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25267] = 16, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26144] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(629), 1, - aux_sym_widget_field_token1, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(544), 2, + STATE(564), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(494), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61208,67 +65461,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(906), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25352] = 13, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26206] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(545), 2, + STATE(565), 2, sym_comment, sym_include, - ACTIONS(645), 3, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(908), 36, + ACTIONS(446), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61279,59 +65519,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25431] = 10, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26268] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(546), 2, + STATE(566), 2, sym_comment, sym_include, - ACTIONS(647), 4, + ACTIONS(512), 49, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(910), 39, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61342,60 +65577,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25504] = 16, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26330] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(631), 1, - aux_sym_widget_field_token1, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(547), 2, + STATE(567), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(516), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61406,66 +65635,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(912), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25589] = 12, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26392] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(548), 2, + STATE(568), 2, sym_comment, sym_include, - ACTIONS(649), 3, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(914), 38, + ACTIONS(522), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61476,60 +65693,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25666] = 16, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26454] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(651), 1, - aux_sym_widget_field_token1, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(549), 2, + STATE(569), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(498), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61540,65 +65751,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(916), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25751] = 16, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26516] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(627), 1, - aux_sym_widget_field_token1, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(550), 2, + STATE(570), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(458), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61609,65 +65809,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(918), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25836] = 16, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26578] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(617), 1, - aux_sym_widget_field_token1, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(551), 2, + STATE(571), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(450), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61678,58 +65867,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(920), 17, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [25921] = 15, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26640] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(468), 1, - aux_sym_widget_field_token1, - ACTIONS(619), 1, + STATE(572), 2, + sym_comment, + sym_include, + ACTIONS(540), 49, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + anon_sym_LBRACE, + sym_identifier, + sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, - STATE(552), 2, - sym_comment, - sym_include, - ACTIONS(904), 13, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61740,64 +65925,112 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(470), 23, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26702] = 4, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + STATE(573), 2, + sym_comment, + sym_include, + ACTIONS(422), 49, + anon_sym_SLASH, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [26004] = 7, - ACTIONS(373), 1, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26764] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(922), 1, - anon_sym_NO_DASHERROR, - STATE(553), 2, + STATE(574), 2, sym_comment, sym_include, - ACTIONS(472), 4, + ACTIONS(442), 49, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(474), 41, + anon_sym_LBRACE, + sym_identifier, sym__terminator, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, anon_sym_LPAREN, - anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -61808,52 +66041,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_if_statement_token2, - aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_of_token1, - aux_sym_on_statement_token1, - [26070] = 7, - ACTIONS(373), 1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [26826] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(926), 1, - anon_sym_NO_DASHERROR, - STATE(554), 2, - sym_comment, - sym_include, - ACTIONS(888), 4, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - aux_sym_widget_field_token1, - ACTIONS(924), 41, - sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(575), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_input_expression_token2, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -61867,6 +66096,10 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, + ACTIONS(960), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, aux_sym_variable_tuning_token1, aux_sym_variable_tuning_token2, aux_sym_variable_tuning_token3, @@ -61876,72 +66109,48 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_COMMA, aux_sym_if_statement_token2, aux_sym_else_if_statement_token1, - anon_sym_COLON, - aux_sym_do_while_statement_token1, - aux_sym_do_statement_token1, - aux_sym_on_error_phrase_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, aux_sym_on_statement_token1, - [26136] = 23, - ACTIONS(373), 1, + [26909] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(928), 1, - anon_sym_RPAREN, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(499), 1, sym__logical_operator, - STATE(1555), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - ACTIONS(625), 2, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(555), 2, + STATE(576), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -61955,66 +66164,61 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26232] = 23, - ACTIONS(373), 1, + ACTIONS(970), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [26992] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(940), 1, - anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(499), 1, sym__logical_operator, - STATE(1563), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - ACTIONS(625), 2, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(556), 2, + STATE(577), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62028,66 +66232,63 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26328] = 23, - ACTIONS(373), 1, + ACTIONS(972), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27075] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(942), 1, - anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(499), 1, sym__logical_operator, - STATE(1547), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - ACTIONS(625), 2, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(667), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(557), 2, + STATE(578), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(974), 37, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62101,66 +66302,57 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26424] = 23, - ACTIONS(373), 1, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27154] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(944), 1, - anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(499), 1, sym__logical_operator, - STATE(1554), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - ACTIONS(625), 2, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(558), 2, + STATE(579), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62174,66 +66366,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26520] = 23, - ACTIONS(373), 1, + ACTIONS(976), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27237] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(946), 1, - anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(499), 1, sym__logical_operator, - STATE(1545), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - ACTIONS(625), 2, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(559), 2, + STATE(580), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(898), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62247,66 +66427,355 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26616] = 23, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, + ACTIONS(552), 24, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(948), 1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27318] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + STATE(581), 2, + sym_comment, + sym_include, + ACTIONS(625), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(978), 40, + sym__terminator, + anon_sym_LPAREN, anon_sym_RPAREN, - STATE(446), 1, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27391] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, sym__comparison_operator, - STATE(447), 1, + ACTIONS(637), 2, + anon_sym_LT, + anon_sym_GT, + STATE(582), 2, + sym_comment, + sym_include, + ACTIONS(980), 39, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27468] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(583), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + ACTIONS(982), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27551] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, sym__additive_operator, - STATE(450), 1, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(584), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + ACTIONS(984), 18, + sym__terminator, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + anon_sym_COMMA, + aux_sym_if_statement_token2, + aux_sym_else_if_statement_token1, + aux_sym_property_definition_token2, + aux_sym_output_stream_statement_token1, + aux_sym_of_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + aux_sym_on_statement_token1, + [27634] = 23, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(986), 1, + anon_sym_RPAREN, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + STATE(467), 1, sym__logical_operator, - STATE(1549), 1, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1677), 1, aux_sym_can_find_expression_repeat2, - STATE(1576), 1, + STATE(1743), 1, sym__using_first, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(560), 2, + STATE(585), 2, sym_comment, sym_include, - STATE(1708), 3, + STATE(1907), 3, sym_where_clause, sym_query_tuning, sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62320,66 +66789,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26712] = 23, - ACTIONS(373), 1, + [27730] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, + ACTIONS(994), 1, aux_sym_of_token1, - ACTIONS(938), 1, + ACTIONS(996), 1, aux_sym__using_first_token1, - ACTIONS(950), 1, + ACTIONS(998), 1, anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - STATE(1558), 1, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1679), 1, aux_sym_can_find_expression_repeat2, - STATE(1576), 1, + STATE(1743), 1, sym__using_first, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(561), 2, + STATE(586), 2, sym_comment, sym_include, - STATE(1708), 3, + STATE(1907), 3, sym_where_clause, sym_query_tuning, sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62393,66 +66862,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26808] = 23, - ACTIONS(373), 1, + [27826] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, + ACTIONS(994), 1, aux_sym_of_token1, - ACTIONS(938), 1, + ACTIONS(996), 1, aux_sym__using_first_token1, - ACTIONS(952), 1, + ACTIONS(1000), 1, anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - STATE(1564), 1, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1656), 1, aux_sym_can_find_expression_repeat2, - STATE(1576), 1, + STATE(1743), 1, sym__using_first, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(562), 2, + STATE(587), 2, sym_comment, sym_include, - STATE(1708), 3, + STATE(1907), 3, sym_where_clause, sym_query_tuning, sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62466,66 +66935,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [26904] = 23, - ACTIONS(373), 1, + [27922] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, + ACTIONS(994), 1, aux_sym_of_token1, - ACTIONS(938), 1, + ACTIONS(996), 1, aux_sym__using_first_token1, - ACTIONS(954), 1, + ACTIONS(1002), 1, anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - STATE(1562), 1, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1685), 1, aux_sym_can_find_expression_repeat2, - STATE(1576), 1, + STATE(1743), 1, sym__using_first, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(563), 2, + STATE(588), 2, sym_comment, sym_include, - STATE(1708), 3, + STATE(1907), 3, sym_where_clause, sym_query_tuning, sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62539,66 +67008,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27000] = 23, - ACTIONS(373), 1, + [28018] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(930), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, + ACTIONS(994), 1, aux_sym_of_token1, - ACTIONS(938), 1, + ACTIONS(996), 1, aux_sym__using_first_token1, - ACTIONS(956), 1, + ACTIONS(1004), 1, anon_sym_RPAREN, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - STATE(1546), 1, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1681), 1, aux_sym_can_find_expression_repeat2, - STATE(1576), 1, + STATE(1743), 1, sym__using_first, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(564), 2, + STATE(589), 2, sym_comment, sym_include, - STATE(1708), 3, + STATE(1907), 3, sym_where_clause, sym_query_tuning, sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62612,34 +67081,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27096] = 7, - ACTIONS(373), 1, + [28114] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(958), 1, - anon_sym_NO_DASHERROR, - STATE(565), 2, - sym_comment, - sym_include, - ACTIONS(472), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1006), 1, + anon_sym_RPAREN, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1666), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(474), 38, - sym__terminator, - anon_sym_RPAREN, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(590), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62653,48 +67154,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [27158] = 7, - ACTIONS(373), 1, + [28210] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(960), 1, - anon_sym_NO_DASHERROR, - STATE(566), 2, - sym_comment, - sym_include, - ACTIONS(888), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1008), 1, + anon_sym_RPAREN, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1683), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(924), 38, - sym__terminator, - anon_sym_RPAREN, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(591), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62708,54 +67227,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [27220] = 11, - ACTIONS(373), 1, + [28306] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(488), 1, - anon_sym_LPAREN, - ACTIONS(962), 1, - aux_sym_object_access_token1, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(605), 1, - aux_sym_object_access_repeat1, - STATE(567), 2, - sym_comment, - sym_include, - ACTIONS(484), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1010), 1, + anon_sym_RPAREN, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1667), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(486), 33, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(592), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62769,51 +67300,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [27289] = 11, - ACTIONS(373), 1, + [28402] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(488), 1, - anon_sym_LPAREN, - ACTIONS(962), 1, - aux_sym_object_access_token1, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(605), 1, - aux_sym_object_access_repeat1, - STATE(568), 2, - sym_comment, - sym_include, - ACTIONS(500), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1012), 1, + anon_sym_RPAREN, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1672), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(502), 33, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(593), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62827,65 +67373,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [27358] = 15, - ACTIONS(373), 1, + [28498] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1014), 1, + anon_sym_RPAREN, + STATE(467), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1659), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(569), 2, + STATE(594), 2, sym_comment, sym_include, - ACTIONS(898), 6, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(906), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62899,43 +67446,66 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27434] = 13, - ACTIONS(373), 1, + [28594] = 23, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1016), 1, + anon_sym_RPAREN, + STATE(467), 1, sym__logical_operator, - ACTIONS(645), 2, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1680), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(570), 2, + STATE(595), 2, sym_comment, sym_include, - ACTIONS(908), 30, - sym__terminator, - anon_sym_RPAREN, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -62949,38 +67519,104 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, + [28690] = 23, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(988), 1, aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(1018), 1, + anon_sym_RPAREN, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(1670), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(596), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [27506] = 10, - ACTIONS(373), 1, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [28786] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, - sym__logical_operator, - STATE(430), 1, - sym__additive_operator, - STATE(571), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(1020), 1, + anon_sym_LPAREN, + ACTIONS(1022), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(630), 1, + aux_sym_object_access_repeat1, + STATE(597), 2, sym_comment, sym_include, - ACTIONS(647), 3, + ACTIONS(532), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(910), 33, + ACTIONS(534), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -63014,54 +67650,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - [27572] = 15, - ACTIONS(373), 1, + [28855] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(1020), 1, + anon_sym_LPAREN, + ACTIONS(1022), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(630), 1, + aux_sym_object_access_repeat1, + STATE(598), 2, + sym_comment, + sym_include, + ACTIONS(454), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, - sym__logical_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(572), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(456), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(918), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63075,42 +67697,53 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27648] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [28924] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(573), 2, + STATE(599), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(896), 11, + ACTIONS(984), 11, sym__terminator, anon_sym_RPAREN, aux_sym_where_clause_token1, @@ -63122,7 +67755,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63136,42 +67769,35 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27724] = 12, - ACTIONS(373), 1, + [29000] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(529), 1, sym__additive_operator, - STATE(450), 1, + STATE(530), 1, sym__logical_operator, - ACTIONS(649), 2, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - STATE(574), 2, - sym_comment, - sym_include, - ACTIONS(914), 32, - sym__terminator, - anon_sym_RPAREN, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, + STATE(600), 2, + sym_comment, + sym_include, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63185,51 +67811,60 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_where_clause_token1, + ACTIONS(552), 17, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [27794] = 15, - ACTIONS(373), 1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [29074] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(421), 1, - sym__logical_operator, - STATE(430), 1, + STATE(529), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(575), 2, + STATE(601), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(964), 11, + ACTIONS(960), 11, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, @@ -63241,7 +67876,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63255,29 +67890,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [27870] = 10, - ACTIONS(373), 1, + [29150] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - STATE(576), 2, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + STATE(602), 2, sym_comment, sym_include, - ACTIONS(647), 3, + ACTIONS(625), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(910), 33, + ACTIONS(978), 33, sym__terminator, anon_sym_RPAREN, aux_sym__logical_operator_token1, @@ -63311,35 +67946,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, - [27936] = 14, - ACTIONS(373), 1, + [29216] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(577), 2, + STATE(603), 2, sym_comment, sym_include, - ACTIONS(904), 13, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(960), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63353,72 +68007,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(470), 17, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [28010] = 15, - ACTIONS(373), 1, + [29292] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(578), 2, + STATE(604), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(896), 11, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, + ACTIONS(970), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - ACTIONS(904), 13, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63432,54 +68068,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28086] = 15, - ACTIONS(373), 1, + [29368] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(579), 2, + STATE(605), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(918), 11, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, + ACTIONS(1024), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - ACTIONS(904), 13, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63493,54 +68129,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28162] = 15, - ACTIONS(373), 1, + [29444] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(529), 1, sym__additive_operator, - STATE(450), 1, + STATE(530), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(580), 2, + STATE(606), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(964), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, + ACTIONS(1024), 11, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63554,54 +68190,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28238] = 15, - ACTIONS(373), 1, + [29520] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(529), 1, sym__additive_operator, - STATE(450), 1, + STATE(530), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(581), 2, + STATE(607), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(920), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, + ACTIONS(970), 11, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63615,54 +68251,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28314] = 15, - ACTIONS(373), 1, + [29596] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(529), 1, sym__additive_operator, - STATE(450), 1, + STATE(530), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(582), 2, + STATE(608), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(916), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, + ACTIONS(972), 11, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63676,42 +68312,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28390] = 15, - ACTIONS(373), 1, + [29672] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(421), 1, - sym__logical_operator, - STATE(430), 1, + STATE(529), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(583), 2, + STATE(609), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(920), 11, + ACTIONS(976), 11, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, @@ -63723,7 +68359,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63737,41 +68373,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28466] = 13, - ACTIONS(373), 1, + [29748] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(645), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(584), 2, + STATE(610), 2, sym_comment, sym_include, - ACTIONS(908), 30, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(972), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63785,47 +68434,43 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [28538] = 8, - ACTIONS(373), 1, + [29824] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - STATE(591), 1, - aux_sym_qualified_name_repeat1, - STATE(585), 2, - sym_comment, - sym_include, - ACTIONS(377), 4, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(667), 2, anon_sym_LT, anon_sym_GT, - anon_sym_LIKE, - ACTIONS(381), 34, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(611), 2, + sym_comment, + sym_include, + ACTIONS(974), 30, sym__terminator, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63839,65 +68484,63 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [28600] = 15, - ACTIONS(373), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [29896] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(586), 2, + STATE(612), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(916), 11, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, + ACTIONS(982), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - ACTIONS(904), 13, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63911,54 +68554,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28676] = 15, - ACTIONS(373), 1, + [29972] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(421), 1, - sym__logical_operator, - STATE(430), 1, + STATE(529), 1, sym__additive_operator, - ACTIONS(625), 2, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(667), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(587), 2, + STATE(613), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(974), 30, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(912), 11, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - ACTIONS(904), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -63972,54 +68602,49 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28752] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [30044] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, + STATE(527), 1, sym__multiplicative_operator, - STATE(448), 1, + STATE(529), 1, sym__additive_operator, - STATE(450), 1, + STATE(530), 1, sym__logical_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(588), 2, + STATE(541), 1, + sym__comparison_operator, + STATE(614), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(625), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(978), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(912), 11, - sym__terminator, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64033,42 +68658,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [28828] = 15, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, - sym__logical_operator, - STATE(430), 1, - sym__additive_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(589), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(906), 11, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, @@ -64080,49 +68669,35 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - ACTIONS(904), 13, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - [28904] = 14, - ACTIONS(373), 1, + [30110] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(446), 1, - sym__comparison_operator, - STATE(447), 1, - sym__multiplicative_operator, - STATE(448), 1, - sym__additive_operator, - STATE(450), 1, + STATE(467), 1, sym__logical_operator, - ACTIONS(625), 2, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(590), 2, + STATE(615), 2, sym_comment, sym_include, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64136,7 +68711,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(470), 17, + ACTIONS(552), 17, sym__terminator, anon_sym_RPAREN, aux_sym__logical_operator_token1, @@ -64154,35 +68729,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_of_token1, aux_sym__using_first_token1, - [28978] = 7, - ACTIONS(373), 1, + [30184] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(968), 1, - sym__namedot, - STATE(591), 3, - sym_comment, - sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 4, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(467), 1, + sym__logical_operator, + STATE(478), 1, + sym__additive_operator, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - anon_sym_LIKE, - ACTIONS(387), 34, - sym__terminator, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(616), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(976), 11, + sym__terminator, + anon_sym_RPAREN, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64196,43 +68790,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29038] = 12, - ACTIONS(373), 1, + [30260] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(416), 1, - sym__comparison_operator, - STATE(418), 1, - sym__multiplicative_operator, - STATE(421), 1, + STATE(467), 1, sym__logical_operator, - STATE(430), 1, + STATE(478), 1, sym__additive_operator, - ACTIONS(649), 2, + STATE(484), 1, + sym__multiplicative_operator, + STATE(487), 1, + sym__comparison_operator, + ACTIONS(637), 2, anon_sym_LT, anon_sym_GT, - STATE(592), 2, + STATE(617), 2, sym_comment, sym_include, - ACTIONS(914), 32, + ACTIONS(980), 32, + sym__terminator, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -64254,43 +68839,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [29108] = 11, - ACTIONS(373), 1, + aux_sym_of_token1, + aux_sym__using_first_token1, + [30330] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(971), 1, - anon_sym_LPAREN, - ACTIONS(973), 1, - aux_sym_object_access_token1, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(617), 1, - aux_sym_object_access_repeat1, - STATE(593), 2, - sym_comment, - sym_include, - ACTIONS(484), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(527), 1, + sym__multiplicative_operator, + STATE(529), 1, + sym__additive_operator, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(637), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(486), 31, - sym__terminator, + STATE(618), 2, + sym_comment, + sym_include, + ACTIONS(980), 32, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -64299,7 +68882,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64313,100 +68895,65 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29175] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [30400] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(594), 2, - sym_comment, - sym_include, - ACTIONS(385), 4, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(527), 1, + sym__multiplicative_operator, + STATE(529), 1, + sym__additive_operator, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - anon_sym_LIKE, - ACTIONS(387), 35, - sym__namedot, - sym__terminator, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29232] = 11, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(971), 1, - anon_sym_LPAREN, - ACTIONS(973), 1, - aux_sym_object_access_token1, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(617), 1, - aux_sym_object_access_repeat1, - STATE(595), 2, + STATE(619), 2, sym_comment, sym_include, - ACTIONS(500), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(502), 31, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(982), 11, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64420,54 +68967,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29299] = 7, - ACTIONS(373), 1, + [30476] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(488), 1, - anon_sym_LPAREN, - STATE(596), 2, - sym_comment, - sym_include, - ACTIONS(611), 4, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(527), 1, + sym__multiplicative_operator, + STATE(529), 1, + sym__additive_operator, + STATE(530), 1, + sym__logical_operator, + STATE(541), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - aux_sym_object_access_token1, - ACTIONS(613), 33, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(620), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, + ACTIONS(984), 11, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, @@ -64479,35 +69014,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - [29357] = 14, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(597), 2, - sym_comment, - sym_include, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64521,71 +69028,63 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - ACTIONS(470), 15, - sym__terminator, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29429] = 15, - ACTIONS(373), 1, + [30552] = 22, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1034), 1, + aux_sym_widget_field_token1, + STATE(397), 1, sym__logical_operator, - STATE(438), 1, + STATE(401), 1, sym__additive_operator, - STATE(441), 1, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + STATE(1244), 1, + sym_do_block, + STATE(1937), 1, + aux_sym_on_statement_repeat1, + STATE(2082), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(598), 2, + STATE(621), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(896), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -64596,55 +69095,63 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [29503] = 15, - ACTIONS(373), 1, + [30641] = 22, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1038), 1, + aux_sym_widget_field_token1, + STATE(397), 1, sym__logical_operator, - STATE(438), 1, + STATE(401), 1, sym__additive_operator, - STATE(441), 1, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + STATE(1217), 1, + sym_do_block, + STATE(1935), 1, + aux_sym_on_statement_repeat1, + STATE(2083), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(599), 2, + STATE(622), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(975), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -64655,55 +69162,63 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [29577] = 15, - ACTIONS(373), 1, + [30730] = 22, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1040), 1, + aux_sym_widget_field_token1, + STATE(397), 1, sym__logical_operator, - STATE(438), 1, + STATE(401), 1, sym__additive_operator, - STATE(441), 1, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + STATE(1421), 1, + sym_do_block, + STATE(1900), 1, + aux_sym_on_statement_repeat1, + STATE(2090), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(600), 2, + STATE(623), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(918), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -64714,55 +69229,130 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [29651] = 15, - ACTIONS(373), 1, + [30819] = 22, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1042), 1, + aux_sym_widget_field_token1, + STATE(397), 1, sym__logical_operator, - STATE(438), 1, + STATE(401), 1, sym__additive_operator, - STATE(441), 1, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(1451), 1, + sym_do_block, + STATE(1916), 1, + aux_sym_on_statement_repeat1, + STATE(2055), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(624), 2, + sym_comment, + sym_include, + ACTIONS(631), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(635), 15, anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, anon_sym_GT, - ACTIONS(900), 2, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [30908] = 22, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1044), 1, + aux_sym_widget_field_token1, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + STATE(1305), 1, + sym_do_block, + STATE(1936), 1, + aux_sym_on_statement_repeat1, + STATE(2038), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(601), 2, + STATE(625), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(916), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -64773,24 +69363,92 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [29725] = 7, - ACTIONS(373), 1, + [30997] = 22, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(977), 1, - aux_sym_object_access_token1, - ACTIONS(588), 3, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1046), 1, + aux_sym_widget_field_token1, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + STATE(1382), 1, + sym_do_block, + STATE(1899), 1, + aux_sym_on_statement_repeat1, + STATE(2042), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + ACTIONS(629), 2, anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(626), 2, + sym_comment, + sym_include, + ACTIONS(631), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(635), 15, anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, anon_sym_GT, - STATE(602), 3, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [31086] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(627), 2, sym_comment, sym_include, - aux_sym_object_access_repeat1, - ACTIONS(590), 33, + ACTIONS(446), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(448), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -64824,33 +69482,24 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - [29783] = 12, - ACTIONS(373), 1, + [31146] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1048), 1, + aux_sym_object_access_token1, + ACTIONS(608), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - ACTIONS(649), 2, anon_sym_LT, anon_sym_GT, - STATE(603), 2, + STATE(628), 3, sym_comment, sym_include, - ACTIONS(914), 30, - sym__terminator, + aux_sym_object_access_repeat1, + ACTIONS(610), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -64859,6 +69508,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64872,50 +69522,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29851] = 13, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31204] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(629), 2, + sym_comment, + sym_include, + ACTIONS(544), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - ACTIONS(645), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(604), 2, - sym_comment, - sym_include, - ACTIONS(908), 28, - sym__terminator, + ACTIONS(546), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -64929,33 +69574,36 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [29921] = 8, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31264] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(962), 1, + ACTIONS(1022), 1, aux_sym_object_access_token1, - STATE(602), 1, + STATE(628), 1, aux_sym_object_access_repeat1, - STATE(605), 2, + STATE(630), 2, sym_comment, sym_include, - ACTIONS(607), 3, + ACTIONS(621), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(609), 33, + ACTIONS(623), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -64989,52 +69637,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - [29981] = 15, - ACTIONS(373), 1, + [31324] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, + STATE(499), 1, sym__logical_operator, - STATE(438), 1, + STATE(503), 1, sym__additive_operator, - STATE(441), 1, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(606), 2, + STATE(631), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(920), 9, + ACTIONS(1051), 9, sym__terminator, aux_sym_variable_tuning_token1, aux_sym_variable_tuning_token2, aux_sym_variable_tuning_token3, aux_sym_variable_tuning_token4, aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, + aux_sym_property_definition_token2, aux_sym_field_definition_token1, aux_sym_index_definition_token1, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65048,52 +69696,33 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30055] = 15, - ACTIONS(373), 1, + [31398] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1020), 1, + anon_sym_LPAREN, + STATE(632), 2, + sym_comment, + sym_include, + ACTIONS(661), 4, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(607), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + aux_sym_object_access_token1, + ACTIONS(663), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(906), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65107,30 +69736,36 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30129] = 10, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31456] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - STATE(608), 2, + ACTIONS(1053), 1, + anon_sym_NO_DASHERROR, + STATE(633), 2, sym_comment, sym_include, - ACTIONS(647), 3, + ACTIONS(540), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(910), 31, + ACTIONS(542), 33, sym__terminator, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65153,60 +69788,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [30193] = 15, - ACTIONS(373), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [31513] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1055), 1, + sym__namedot, + STATE(634), 2, + sym_comment, + sym_include, + ACTIONS(422), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(371), 1, - sym__multiplicative_operator, - STATE(437), 1, - sym__logical_operator, - STATE(438), 1, - sym__additive_operator, - STATE(441), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(609), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(424), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(912), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65220,58 +69836,43 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30267] = 22, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31570] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1057), 1, + anon_sym_NO_DASHERROR, + STATE(635), 2, + sym_comment, + sym_include, + ACTIONS(540), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(986), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1264), 1, - sym_do_block, - STATE(1786), 1, - aux_sym_on_statement_repeat1, - STATE(2010), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(610), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(542), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65285,58 +69886,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30354] = 22, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31627] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + STATE(636), 2, + sym_comment, + sym_include, + ACTIONS(436), 4, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(990), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1085), 1, - sym_do_block, - STATE(1776), 1, - aux_sym_on_statement_repeat1, - STATE(2022), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(611), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + aux_sym_object_access_token1, + ACTIONS(438), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65350,22 +69935,33 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30441] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31682] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(612), 2, + STATE(637), 2, sym_comment, sym_include, - ACTIONS(633), 4, + ACTIONS(657), 4, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, aux_sym_object_access_token1, - ACTIONS(635), 33, + ACTIONS(659), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65399,58 +69995,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_query_tuning_token6, aux_sym_sort_clause_token1, aux_sym_sort_clause_token2, - [30496] = 22, - ACTIONS(373), 1, + [31737] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1059), 1, + anon_sym_NO_DASHERROR, + STATE(638), 2, + sym_comment, + sym_include, + ACTIONS(906), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(992), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1168), 1, - sym_do_block, - STATE(1788), 1, - aux_sym_on_statement_repeat1, - STATE(1953), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(613), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(954), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65464,123 +70034,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30583] = 22, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31794] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(994), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1038), 1, - sym_do_block, - STATE(1780), 1, - aux_sym_on_statement_repeat1, - STATE(2073), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(614), 2, + ACTIONS(1061), 1, + anon_sym_NO_DASHERROR, + STATE(639), 2, sym_comment, sym_include, - ACTIONS(898), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(904), 13, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - [30670] = 22, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(906), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(996), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1351), 1, - sym_do_block, - STATE(1801), 1, - aux_sym_on_statement_repeat1, - STATE(2076), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(615), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(954), 33, + sym__terminator, + anon_sym_RPAREN, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65594,58 +70086,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30757] = 22, - ACTIONS(373), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [31851] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + STATE(640), 2, + sym_comment, + sym_include, + ACTIONS(432), 4, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(998), 1, - aux_sym_widget_field_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - STATE(1308), 1, - sym_do_block, - STATE(1796), 1, - aux_sym_on_statement_repeat1, - STATE(2052), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(616), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + aux_sym_object_access_token1, + ACTIONS(434), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65659,26 +70133,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [30844] = 8, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31906] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(973), 1, - aux_sym_object_access_token1, - STATE(621), 1, - aux_sym_object_access_repeat1, - STATE(617), 2, + STATE(641), 2, sym_comment, sym_include, - ACTIONS(607), 3, + ACTIONS(458), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(609), 31, - sym__terminator, + ACTIONS(460), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65701,34 +70181,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [30902] = 8, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [31960] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(618), 2, + STATE(642), 2, sym_comment, sym_include, - ACTIONS(426), 3, + ACTIONS(532), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(428), 31, - sym__terminator, + ACTIONS(534), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65751,34 +70229,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [30960] = 8, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32014] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(619), 2, + STATE(643), 2, sym_comment, sym_include, - ACTIONS(422), 3, + ACTIONS(406), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(424), 31, - sym__terminator, + ACTIONS(408), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65801,32 +70277,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31018] = 7, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32068] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(971), 1, - anon_sym_LPAREN, - STATE(620), 2, + STATE(644), 2, sym_comment, sym_include, - ACTIONS(611), 3, + ACTIONS(414), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(613), 32, - sym__terminator, + ACTIONS(416), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65849,34 +70325,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_object_access_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31074] = 7, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32122] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1000), 1, - aux_sym_object_access_token1, - ACTIONS(588), 3, + STATE(645), 2, + sym_comment, + sym_include, + ACTIONS(504), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - STATE(621), 3, - sym_comment, - sym_include, - aux_sym_object_access_repeat1, - ACTIONS(590), 31, - sym__terminator, + ACTIONS(506), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -65899,58 +70373,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31130] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32176] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + STATE(646), 2, + sym_comment, + sym_include, + ACTIONS(422), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(622), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(424), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(1003), 7, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -65964,22 +70421,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [31202] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32230] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(623), 2, + STATE(647), 2, sym_comment, sym_include, - ACTIONS(633), 3, + ACTIONS(508), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(635), 32, - sym__terminator, + ACTIONS(510), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66002,33 +70469,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_object_access_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31255] = 7, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32284] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1005), 1, - anon_sym_NO_DASHERROR, - STATE(624), 2, + STATE(648), 2, sym_comment, sym_include, - ACTIONS(888), 3, + ACTIONS(454), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(924), 31, - sym__terminator, + ACTIONS(456), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66051,32 +70517,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31310] = 7, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32338] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1007), 1, - anon_sym_NO_DASHERROR, - STATE(625), 2, + STATE(649), 2, sym_comment, sym_include, - ACTIONS(472), 3, + ACTIONS(450), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(474), 31, - sym__terminator, + ACTIONS(452), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66099,30 +70565,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31365] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32392] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(626), 2, + STATE(650), 2, sym_comment, sym_include, - ACTIONS(448), 3, + ACTIONS(418), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(450), 32, - sym__terminator, + ACTIONS(420), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66145,31 +70613,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_object_access_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31418] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32446] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(627), 2, + STATE(651), 2, sym_comment, sym_include, - ACTIONS(460), 3, + ACTIONS(410), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(462), 32, - sym__terminator, + ACTIONS(412), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66192,33 +70661,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_object_access_token1, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31471] = 7, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32500] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1009), 1, - sym__namedot, - STATE(628), 2, + STATE(652), 2, sym_comment, sym_include, - ACTIONS(412), 3, + ACTIONS(442), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 31, - sym__terminator, + ACTIONS(444), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66241,57 +70709,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31526] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32554] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + STATE(653), 2, + sym_comment, + sym_include, + ACTIONS(402), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(629), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(404), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(1011), 6, - aux_sym_input_expression_token2, - anon_sym_COMMA, - aux_sym_do_while_statement_token1, - aux_sym_of_token1, - aux_sym_widget_field_token1, - aux_sym_on_statement_token1, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -66305,22 +70757,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [31597] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32608] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(630), 2, + STATE(654), 2, sym_comment, sym_include, - ACTIONS(516), 3, + ACTIONS(490), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(518), 31, - sym__terminator, + ACTIONS(492), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66343,30 +70805,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31649] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32662] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(631), 2, + STATE(655), 2, sym_comment, sym_include, - ACTIONS(540), 3, + ACTIONS(446), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(542), 31, - sym__terminator, + ACTIONS(448), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66389,30 +70853,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31701] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32716] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(632), 2, + STATE(656), 2, sym_comment, sym_include, - ACTIONS(524), 3, + ACTIONS(512), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(526), 31, - sym__terminator, + ACTIONS(514), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66435,39 +70901,61 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31753] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32770] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(633), 2, - sym_comment, - sym_include, - ACTIONS(400), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(402), 31, - sym__terminator, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(657), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(1063), 7, + sym__terminator, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -66481,30 +70969,21 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31805] = 6, - ACTIONS(373), 1, + [32842] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(634), 2, + STATE(658), 2, sym_comment, sym_include, - ACTIONS(492), 3, + ACTIONS(498), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(494), 31, - sym__terminator, + ACTIONS(500), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66527,30 +71006,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31857] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32896] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(635), 2, + STATE(659), 2, sym_comment, sym_include, - ACTIONS(426), 3, + ACTIONS(494), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(428), 31, - sym__terminator, + ACTIONS(496), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66573,30 +71054,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31909] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [32950] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(636), 2, + STATE(660), 2, sym_comment, sym_include, - ACTIONS(408), 3, + ACTIONS(550), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(410), 31, - sym__terminator, + ACTIONS(552), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66619,30 +71102,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [31961] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33004] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(637), 2, + STATE(661), 2, sym_comment, sym_include, - ACTIONS(392), 3, + ACTIONS(462), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(394), 31, - sym__terminator, + ACTIONS(464), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66665,30 +71150,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32013] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33058] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(638), 2, + STATE(662), 2, sym_comment, sym_include, - ACTIONS(508), 3, + ACTIONS(540), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(510), 31, - sym__terminator, + ACTIONS(542), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66711,30 +71198,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32065] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33112] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(639), 2, + STATE(663), 2, sym_comment, sym_include, - ACTIONS(396), 3, + ACTIONS(466), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(398), 31, - sym__terminator, + ACTIONS(468), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66757,30 +71246,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32117] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33166] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(640), 2, + STATE(664), 2, sym_comment, sym_include, - ACTIONS(412), 3, + ACTIONS(428), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 31, - sym__terminator, + ACTIONS(430), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66803,30 +71294,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32169] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33220] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(641), 2, + STATE(665), 2, sym_comment, sym_include, - ACTIONS(528), 3, + ACTIONS(522), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(530), 31, - sym__terminator, + ACTIONS(524), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66849,30 +71342,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32221] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33274] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(642), 2, + STATE(666), 2, sym_comment, sym_include, - ACTIONS(404), 3, + ACTIONS(516), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(406), 31, - sym__terminator, + ACTIONS(518), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66895,30 +71390,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32273] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33328] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(643), 2, + STATE(667), 2, sym_comment, sym_include, - ACTIONS(418), 3, + ACTIONS(482), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(420), 31, - sym__terminator, + ACTIONS(484), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -66941,76 +71438,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32325] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(185), 1, - sym__namedot, - STATE(653), 1, - aux_sym_qualified_name_repeat1, - STATE(644), 2, - sym_comment, - sym_include, - ACTIONS(377), 33, - anon_sym_LBRACE, - sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_where_clause_token1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, aux_sym_query_tuning_token6, - aux_sym_can_find_expression_token1, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [32377] = 6, - ACTIONS(373), 1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33382] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(645), 2, + STATE(668), 2, sym_comment, sym_include, - ACTIONS(532), 3, + ACTIONS(544), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(534), 31, - sym__terminator, + ACTIONS(546), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67033,30 +71486,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32429] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33436] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(646), 2, + STATE(669), 2, sym_comment, sym_include, - ACTIONS(536), 3, + ACTIONS(486), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(538), 31, - sym__terminator, + ACTIONS(488), 33, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67079,44 +71534,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32481] = 9, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [33490] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1013), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1065), 1, anon_sym_LPAREN, - ACTIONS(1015), 1, + ACTIONS(1067), 1, aux_sym_object_access_token1, - ACTIONS(1017), 1, + ACTIONS(1069), 1, sym__namedot, - STATE(690), 1, - aux_sym_object_access_repeat1, - STATE(694), 1, + STATE(716), 1, aux_sym_qualified_name_repeat1, - STATE(647), 2, + STATE(732), 1, + aux_sym_object_access_repeat1, + STATE(670), 2, sym_comment, sym_include, - ACTIONS(500), 30, + ACTIONS(454), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -67135,23 +71593,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [32539] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [33551] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(648), 2, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(1071), 1, + aux_sym_object_access_token1, + ACTIONS(1073), 1, + sym__namedot, + STATE(733), 1, + aux_sym_qualified_name_repeat1, + STATE(736), 1, + aux_sym_object_access_repeat1, + STATE(671), 2, sym_comment, sym_include, - ACTIONS(480), 3, + ACTIONS(532), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(482), 31, - sym__terminator, + ACTIONS(534), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67174,30 +71643,36 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32591] = 6, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [33614] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(649), 2, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(1071), 1, + aux_sym_object_access_token1, + ACTIONS(1073), 1, + sym__namedot, + STATE(733), 1, + aux_sym_qualified_name_repeat1, + STATE(736), 1, + aux_sym_object_access_repeat1, + STATE(672), 2, sym_comment, sym_include, - ACTIONS(476), 3, + ACTIONS(454), 3, anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(478), 31, - sym__terminator, + ACTIONS(456), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67220,42 +71695,49 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32643] = 6, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [33677] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(650), 2, + ACTIONS(1065), 1, + anon_sym_LPAREN, + ACTIONS(1067), 1, + aux_sym_object_access_token1, + ACTIONS(1069), 1, + sym__namedot, + STATE(716), 1, + aux_sym_qualified_name_repeat1, + STATE(732), 1, + aux_sym_object_access_repeat1, + STATE(673), 2, sym_comment, sym_include, - ACTIONS(484), 3, + ACTIONS(532), 30, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(486), 31, - sym__terminator, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67266,47 +71748,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32695] = 9, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [33738] = 13, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1013), 1, - anon_sym_LPAREN, - ACTIONS(1015), 1, - aux_sym_object_access_token1, - ACTIONS(1017), 1, - sym__namedot, - STATE(690), 1, - aux_sym_object_access_repeat1, - STATE(694), 1, - aux_sym_qualified_name_repeat1, - STATE(651), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(674), 2, sym_comment, sym_include, - ACTIONS(484), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(647), 5, sym_identifier, - anon_sym_DQUOTE, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -67322,32 +71804,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [32753] = 6, - ACTIONS(373), 1, + [33804] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(652), 2, - sym_comment, - sym_include, - ACTIONS(464), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, + sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(466), 31, - sym__terminator, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(675), 2, + sym_comment, + sym_include, + ACTIONS(982), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -67361,75 +71859,30 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32805] = 5, + [33874] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1019), 1, + ACTIONS(1075), 1, + anon_sym_LPAREN, + ACTIONS(1077), 1, + aux_sym_object_access_token1, + ACTIONS(1079), 1, sym__namedot, - STATE(653), 3, + STATE(744), 1, + aux_sym_object_access_repeat1, + STATE(764), 1, + aux_sym_qualified_name_repeat1, + STATE(676), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 33, + ACTIONS(532), 30, + anon_sym_SLASH, anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_can_find_expression_token1, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [32855] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(654), 2, - sym_comment, - sym_include, - ACTIONS(512), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(514), 31, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67439,9 +71892,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67452,42 +71907,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32907] = 6, - ACTIONS(373), 1, + aux_sym_include_argument_token1, + [33932] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(655), 2, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(677), 2, sym_comment, sym_include, - ACTIONS(504), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(506), 31, - sym__terminator, + ACTIONS(1081), 5, + sym_identifier, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67498,30 +71961,76 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [32959] = 6, - ACTIONS(373), 1, + [33998] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(212), 1, + sym__namedot, + STATE(686), 1, + aux_sym_qualified_name_repeat1, + STATE(678), 2, + sym_comment, + sym_include, + ACTIONS(61), 33, anon_sym_LBRACE, - STATE(656), 2, + sym_identifier, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_can_find_expression_token1, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [34050] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(1075), 1, + anon_sym_LPAREN, + ACTIONS(1077), 1, + aux_sym_object_access_token1, + ACTIONS(1079), 1, + sym__namedot, + STATE(744), 1, + aux_sym_object_access_repeat1, + STATE(764), 1, + aux_sym_qualified_name_repeat1, + STATE(679), 2, sym_comment, sym_include, - ACTIONS(472), 3, + ACTIONS(454), 30, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(474), 31, - sym__terminator, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -67531,9 +72040,11 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67544,42 +72055,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33011] = 6, - ACTIONS(373), 1, + aux_sym_include_argument_token1, + [34108] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(657), 2, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(680), 2, sym_comment, sym_include, - ACTIONS(468), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(470), 31, - sym__terminator, + ACTIONS(667), 26, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + aux_sym_input_expression_token2, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67590,39 +72104,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33063] = 6, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [34170] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(658), 2, - sym_comment, - sym_include, - ACTIONS(500), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1085), 1, + anon_sym_BY, + STATE(388), 1, + sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(502), 31, - sym__terminator, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(681), 2, + sym_comment, + sym_include, + ACTIONS(1083), 4, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -67636,39 +72163,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33115] = 6, - ACTIONS(373), 1, + [34242] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(659), 2, - sym_comment, - sym_include, - ACTIONS(520), 3, + ACTIONS(629), 1, anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, + sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(522), 31, - sym__terminator, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(682), 2, + sym_comment, + sym_include, + ACTIONS(552), 11, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -67682,42 +72217,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33167] = 6, - ACTIONS(373), 1, + [34310] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(660), 2, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(683), 2, sym_comment, sym_include, - ACTIONS(496), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(498), 31, - sym__terminator, + ACTIONS(550), 11, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67728,42 +72269,49 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33219] = 6, - ACTIONS(373), 1, + [34374] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(661), 2, + STATE(397), 1, + sym__logical_operator, + STATE(401), 1, + sym__additive_operator, + STATE(405), 1, + sym__multiplicative_operator, + STATE(406), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(684), 2, sym_comment, sym_include, - ACTIONS(422), 3, - anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(424), 31, - sym__terminator, + ACTIONS(645), 5, + sym_identifier, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67774,50 +72322,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [33271] = 12, + [34440] = 13, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - ACTIONS(619), 2, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(662), 2, + STATE(685), 2, sym_comment, sym_include, - ACTIONS(651), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(643), 5, sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -67833,47 +72375,96 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33334] = 12, + [34506] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(1087), 1, + sym__namedot, + STATE(686), 3, + sym_comment, + sym_include, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 33, + anon_sym_LBRACE, + sym_identifier, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_can_find_expression_token1, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [34556] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, STATE(396), 1, sym__additive_operator, - STATE(398), 1, - sym__multiplicative_operator, - STATE(400), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(663), 2, + STATE(687), 2, sym_comment, sym_include, - ACTIONS(653), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, + ACTIONS(976), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67884,46 +72475,51 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33397] = 11, - ACTIONS(3), 1, + [34626] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, STATE(396), 1, sym__additive_operator, - STATE(398), 1, - sym__multiplicative_operator, - STATE(400), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(664), 2, + STATE(688), 2, sym_comment, sym_include, - ACTIONS(468), 11, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(972), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - aux_sym_include_argument_token1, - ACTIONS(625), 15, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67934,44 +72530,51 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33458] = 10, - ACTIONS(3), 1, + [34696] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1022), 1, - anon_sym_LPAREN, - ACTIONS(1024), 1, - aux_sym_object_access_token1, - ACTIONS(1026), 1, - sym__namedot, - STATE(741), 1, - aux_sym_object_access_repeat1, - STATE(762), 1, - aux_sym_qualified_name_repeat1, - STATE(665), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, + sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(689), 2, sym_comment, sym_include, - ACTIONS(500), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(970), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -67982,40 +72585,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [33517] = 10, + [34766] = 13, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - ACTIONS(619), 2, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(666), 2, + STATE(690), 2, sym_comment, sym_include, - ACTIONS(645), 26, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(641), 5, sym_identifier, - anon_sym_DQUOTE, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68031,38 +72638,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [33576] = 8, + [34832] = 13, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - STATE(667), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(691), 2, sym_comment, sym_include, - ACTIONS(647), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(655), 5, sym_identifier, - anon_sym_DQUOTE, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68078,39 +72691,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [33631] = 9, + [34898] = 13, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - ACTIONS(619), 2, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - STATE(668), 2, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(692), 2, sym_comment, sym_include, - ACTIONS(649), 28, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(627), 5, sym_identifier, - anon_sym_DQUOTE, + aux_sym_input_expression_token2, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68126,43 +72744,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [33688] = 12, + [34964] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(669), 2, + STATE(693), 2, sym_comment, sym_include, - ACTIONS(1028), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(625), 30, + anon_sym_SLASH, sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68178,42 +72790,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33751] = 12, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [35022] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(397), 1, sym__logical_operator, - STATE(396), 1, + STATE(401), 1, sym__additive_operator, - STATE(398), 1, + STATE(405), 1, sym__multiplicative_operator, - STATE(400), 1, + STATE(406), 1, sym__comparison_operator, - ACTIONS(619), 2, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(670), 2, + STATE(694), 2, sym_comment, sym_include, - ACTIONS(627), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(637), 28, sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68229,47 +72840,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33814] = 12, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [35082] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, STATE(396), 1, sym__additive_operator, - STATE(398), 1, - sym__multiplicative_operator, - STATE(400), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(671), 2, + STATE(695), 2, sym_comment, sym_include, - ACTIONS(629), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, + ACTIONS(960), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -68280,47 +72898,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33877] = 12, - ACTIONS(3), 1, + [35152] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(388), 1, sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, STATE(396), 1, sym__additive_operator, - STATE(398), 1, - sym__multiplicative_operator, - STATE(400), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(667), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(672), 2, + STATE(696), 2, sym_comment, sym_include, - ACTIONS(631), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, + ACTIONS(974), 24, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -68331,47 +72946,46 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [33940] = 12, - ACTIONS(3), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [35218] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(395), 1, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(388), 1, sym__logical_operator, + STATE(394), 1, + sym__comparison_operator, + STATE(395), 1, + sym__multiplicative_operator, STATE(396), 1, sym__additive_operator, - STATE(398), 1, - sym__multiplicative_operator, - STATE(400), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(673), 2, + STATE(697), 2, sym_comment, sym_include, - ACTIONS(617), 5, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - ACTIONS(621), 6, + ACTIONS(625), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(978), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -68382,94 +72996,53 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34003] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(387), 1, - sym__namedot, - STATE(674), 2, - sym_comment, - sym_include, - ACTIONS(385), 33, - anon_sym_LBRACE, - sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_can_find_expression_token1, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [34052] = 18, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [35278] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(1030), 1, - aux_sym_of_token1, - ACTIONS(1032), 1, - aux_sym_on_statement_token1, - STATE(443), 1, + STATE(388), 1, sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(394), 1, sym__comparison_operator, - STATE(2123), 1, - aux_sym_on_statement_repeat1, - ACTIONS(625), 2, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(675), 2, + STATE(698), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(984), 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -68483,50 +73056,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34127] = 18, - ACTIONS(373), 1, + [35348] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(1034), 1, - aux_sym_of_token1, - ACTIONS(1036), 1, - aux_sym_on_statement_token1, - STATE(443), 1, + STATE(388), 1, sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(394), 1, sym__comparison_operator, - STATE(2112), 1, - aux_sym_on_statement_repeat1, - ACTIONS(625), 2, + STATE(395), 1, + sym__multiplicative_operator, + STATE(396), 1, + sym__additive_operator, + ACTIONS(637), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(676), 2, + STATE(699), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(980), 26, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -68540,30 +73103,35 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34202] = 10, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [35412] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1022), 1, - anon_sym_LPAREN, - ACTIONS(1024), 1, - aux_sym_object_access_token1, - ACTIONS(1026), 1, - sym__namedot, - STATE(741), 1, - aux_sym_object_access_repeat1, - STATE(762), 1, - aux_sym_qualified_name_repeat1, - STATE(677), 2, + STATE(535), 1, + sym__comparison_operator, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + STATE(700), 2, sym_comment, sym_include, - ACTIONS(484), 28, - anon_sym_SLASH, + ACTIONS(637), 28, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -68572,7 +73140,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, - anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68588,48 +73155,54 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [34261] = 13, - ACTIONS(3), 1, + aux_sym_include_argument_token1, + [35469] = 18, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(449), 1, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1090), 1, + anon_sym_COMMA, + ACTIONS(1092), 1, + aux_sym_of_token1, + ACTIONS(1094), 1, + aux_sym_on_statement_token1, + STATE(499), 1, sym__logical_operator, - STATE(451), 1, + STATE(503), 1, sym__additive_operator, - STATE(453), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(460), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, + STATE(2467), 1, + aux_sym_on_statement_repeat1, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(678), 2, + STATE(701), 2, sym_comment, sym_include, - ACTIONS(653), 3, - sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -68640,28 +73213,28 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34325] = 10, + [35544] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - STATE(679), 2, + ACTIONS(1096), 1, + anon_sym_LPAREN, + ACTIONS(1098), 1, + aux_sym_object_access_token1, + ACTIONS(1100), 1, + sym__namedot, + STATE(814), 1, + aux_sym_qualified_name_repeat1, + STATE(815), 1, + aux_sym_object_access_repeat1, + STATE(702), 2, sym_comment, sym_include, - ACTIONS(649), 26, + ACTIONS(454), 28, + anon_sym_SLASH, sym_identifier, sym__terminator, aux_sym__logical_operator_token1, @@ -68672,6 +73245,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68688,41 +73262,86 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [34383] = 12, + [35603] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(71), 1, + sym__namedot, + STATE(703), 2, + sym_comment, + sym_include, + ACTIONS(69), 33, anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + sym_identifier, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, + aux_sym_input_expression_token1, + aux_sym_scope_tuning_token1, + aux_sym_if_statement_token1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_can_find_expression_token1, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [35652] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(680), 2, + STATE(704), 2, sym_comment, sym_include, - ACTIONS(468), 9, + ACTIONS(645), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_NO_DASHERROR, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68738,42 +73357,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34445] = 13, + [35715] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(681), 2, + STATE(705), 2, sym_comment, sym_include, - ACTIONS(651), 3, + ACTIONS(655), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68789,37 +73408,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34509] = 9, + [35778] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - STATE(682), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(706), 2, sym_comment, sym_include, - ACTIONS(647), 28, - anon_sym_SLASH, + ACTIONS(643), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68835,40 +73459,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [34565] = 11, + [35841] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(683), 2, + STATE(707), 2, sym_comment, sym_include, - ACTIONS(645), 24, + ACTIONS(627), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68884,43 +73510,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [34625] = 13, + [35904] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(684), 2, + STATE(708), 2, sym_comment, sym_include, - ACTIONS(617), 3, + ACTIONS(647), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68936,42 +73561,39 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34689] = 13, + [35967] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, - sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(685), 2, + ACTIONS(1096), 1, + anon_sym_LPAREN, + ACTIONS(1098), 1, + aux_sym_object_access_token1, + ACTIONS(1100), 1, + sym__namedot, + STATE(814), 1, + aux_sym_qualified_name_repeat1, + STATE(815), 1, + aux_sym_object_access_repeat1, + STATE(709), 2, sym_comment, sym_include, - ACTIONS(627), 3, + ACTIONS(532), 28, + anon_sym_SLASH, sym_identifier, sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -68987,42 +73609,38 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34753] = 13, + anon_sym_NO_DASHERROR, + [36026] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, - anon_sym_SLASH, - anon_sym_STAR, - ACTIONS(623), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(686), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + STATE(710), 2, sym_comment, sym_include, - ACTIONS(629), 3, + ACTIONS(625), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -69038,42 +73656,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34817] = 13, + aux_sym_include_argument_token1, + [36081] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(687), 2, + STATE(711), 2, sym_comment, sym_include, - ACTIONS(1038), 3, + ACTIONS(550), 11, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + aux_sym_include_argument_token1, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -69089,42 +73707,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34881] = 13, + [36142] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(449), 1, - sym__logical_operator, - STATE(451), 1, - sym__additive_operator, - STATE(453), 1, - sym__multiplicative_operator, - STATE(460), 1, + STATE(535), 1, sym__comparison_operator, - ACTIONS(619), 2, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, anon_sym_SLASH, anon_sym_STAR, - ACTIONS(623), 2, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(688), 2, + STATE(712), 2, sym_comment, sym_include, - ACTIONS(631), 3, + ACTIONS(641), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - ACTIONS(621), 6, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(625), 15, + ACTIONS(635), 15, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -69140,47 +73758,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [34945] = 14, - ACTIONS(373), 1, + [36205] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, + STATE(535), 1, + sym__comparison_operator, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, sym__additive_operator, - STATE(382), 1, + STATE(538), 1, sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(689), 2, + STATE(713), 2, sym_comment, sym_include, - ACTIONS(470), 8, + ACTIONS(1102), 5, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69191,38 +73809,53 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35010] = 6, - ACTIONS(3), 1, + [36268] = 18, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(1015), 1, - aux_sym_object_access_token1, - STATE(703), 1, - aux_sym_object_access_repeat1, - STATE(690), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1090), 1, + anon_sym_COMMA, + ACTIONS(1104), 1, + aux_sym_of_token1, + ACTIONS(1106), 1, + aux_sym_on_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + STATE(2481), 1, + aux_sym_on_statement_repeat1, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(714), 2, sym_comment, sym_include, - ACTIONS(607), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69233,21 +73866,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [35059] = 6, + [36343] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1017), 1, - sym__namedot, - STATE(694), 1, - aux_sym_qualified_name_repeat1, - STATE(691), 2, + STATE(535), 1, + sym__comparison_operator, + STATE(536), 1, + sym__multiplicative_operator, + STATE(537), 1, + sym__additive_operator, + STATE(538), 1, + sym__logical_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(715), 2, sym_comment, sym_include, - ACTIONS(426), 30, - anon_sym_SLASH, + ACTIONS(667), 26, anon_sym_LBRACE, anon_sym_RBRACE, sym_identifier, @@ -69258,9 +73899,6 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -69277,48 +73915,38 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, aux_sym_include_argument_token1, - [35108] = 15, - ACTIONS(373), 1, + [36402] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1040), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(692), 2, + ACTIONS(1069), 1, + sym__namedot, + STATE(724), 1, + aux_sym_qualified_name_repeat1, + STATE(716), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(61), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69329,48 +73957,39 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35175] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [36454] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1040), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(693), 2, + ACTIONS(1065), 1, + anon_sym_LPAREN, + STATE(717), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(661), 31, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69381,30 +74000,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35242] = 6, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_object_access_token1, + aux_sym_widget_field_token1, + [36504] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1017), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1069), 1, sym__namedot, - STATE(704), 1, + STATE(716), 1, aux_sym_qualified_name_repeat1, - STATE(694), 2, + STATE(718), 2, sym_comment, sym_include, - ACTIONS(377), 30, + ACTIONS(544), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -69423,98 +74046,43 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [35291] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [36556] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, - sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(918), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(695), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(1071), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(736), 1, + aux_sym_object_access_repeat1, + STATE(719), 2, sym_comment, sym_include, - ACTIONS(898), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(904), 13, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - [35358] = 15, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(454), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, - sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1042), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(696), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(456), 24, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -69528,48 +74096,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35425] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [36616] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(472), 1, sym__logical_operator, - STATE(439), 1, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(906), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(697), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + STATE(720), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(637), 26, + sym_identifier, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69580,45 +74145,35 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35492] = 15, - ACTIONS(373), 1, + anon_sym_NO_DASHERROR, + [36674] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1073), 1, + sym__namedot, + STATE(733), 1, + aux_sym_qualified_name_repeat1, + STATE(721), 2, + sym_comment, + sym_include, + ACTIONS(544), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(1044), 2, - sym__terminator, - aux_sym_do_statement_token1, - STATE(698), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(546), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -69632,28 +74187,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35559] = 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [36728] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1013), 1, - anon_sym_LPAREN, - STATE(699), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1108), 1, + aux_sym_object_access_token1, + STATE(722), 3, sym_comment, sym_include, - ACTIONS(611), 31, + aux_sym_object_access_repeat1, + ACTIONS(608), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -69672,47 +74233,36 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - aux_sym_object_access_token1, - [35606] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [36778] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1111), 1, + sym__namedot, + ACTIONS(69), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, - sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - ACTIONS(916), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(700), 2, + STATE(723), 3, sym_comment, sym_include, - ACTIONS(898), 6, + aux_sym_qualified_name_repeat1, + ACTIONS(71), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -69726,41 +74276,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35673] = 10, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [36830] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, - sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - STATE(701), 2, + ACTIONS(1114), 1, + sym__namedot, + STATE(724), 3, sym_comment, sym_include, - ACTIONS(647), 3, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 30, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(910), 24, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69771,34 +74322,31 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [35730] = 12, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [36880] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(472), 1, sym__logical_operator, - STATE(439), 1, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(649), 2, - anon_sym_LT, - anon_sym_GT, - STATE(702), 2, + STATE(725), 2, sym_comment, sym_include, - ACTIONS(914), 23, + ACTIONS(625), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -69807,9 +74355,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69820,25 +74371,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [35791] = 5, - ACTIONS(3), 1, + anon_sym_NO_DASHERROR, + [36936] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(1046), 1, - aux_sym_object_access_token1, - STATE(703), 3, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1073), 1, + sym__namedot, + STATE(733), 1, + aux_sym_qualified_name_repeat1, + STATE(726), 2, sym_comment, sym_include, - aux_sym_object_access_repeat1, - ACTIONS(588), 30, + ACTIONS(446), 3, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + anon_sym_LT, + anon_sym_GT, + ACTIONS(448), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -69848,11 +74400,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, - anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69863,33 +74413,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [35838] = 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [36990] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1049), 1, - sym__namedot, - STATE(704), 3, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(472), 1, + sym__logical_operator, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, + sym__multiplicative_operator, + STATE(480), 1, + sym__comparison_operator, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(727), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, + ACTIONS(667), 24, sym_identifier, - anon_sym_DQUOTE, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, @@ -69905,49 +74466,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [35885] = 15, - ACTIONS(373), 1, + anon_sym_NO_DASHERROR, + [37050] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(472), 1, sym__logical_operator, - STATE(439), 1, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(896), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(705), 2, + STATE(728), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(645), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -69958,44 +74518,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [35952] = 13, - ACTIONS(373), 1, + [37114] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(472), 1, sym__logical_operator, - STATE(439), 1, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(645), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(706), 2, + STATE(729), 2, sym_comment, sym_include, - ACTIONS(908), 21, + ACTIONS(655), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70006,50 +74569,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [36015] = 15, - ACTIONS(373), 1, + [37178] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(472), 1, sym__logical_operator, - STATE(439), 1, + STATE(474), 1, + sym__additive_operator, + STATE(476), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(920), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(707), 2, + STATE(730), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(647), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70060,45 +74620,46 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36082] = 15, - ACTIONS(373), 1, + [37242] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, + STATE(499), 1, sym__logical_operator, - STATE(439), 1, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, sym__multiplicative_operator, - STATE(470), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - ACTIONS(912), 2, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - STATE(708), 2, + STATE(731), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(1117), 3, + anon_sym_COMMA, + aux_sym_of_token1, + aux_sym_on_statement_token1, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70112,30 +74673,30 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36149] = 6, + [37310] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1017), 1, - sym__namedot, - STATE(694), 1, - aux_sym_qualified_name_repeat1, - STATE(709), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1067), 1, + aux_sym_object_access_token1, + STATE(722), 1, + aux_sym_object_access_repeat1, + STATE(732), 2, sym_comment, sym_include, - ACTIONS(422), 30, + ACTIONS(621), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -70154,45 +74715,89 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [36198] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [37362] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1052), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(1073), 1, + sym__namedot, + STATE(723), 1, + aux_sym_qualified_name_repeat1, + STATE(733), 2, + sym_comment, + sym_include, + ACTIONS(61), 3, + anon_sym_SLASH, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(65), 27, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, anon_sym_PLUS, anon_sym_DASH, - STATE(710), 2, + anon_sym_STAR, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [37416] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(554), 1, + anon_sym_LPAREN, + ACTIONS(1071), 1, + aux_sym_object_access_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(736), 1, + aux_sym_object_access_repeat1, + STATE(734), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(532), 3, + anon_sym_SLASH, + anon_sym_LT, + anon_sym_GT, + ACTIONS(534), 24, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70206,47 +74811,49 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36264] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [37476] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1054), 1, - sym__terminator, - STATE(443), 1, + STATE(472), 1, sym__logical_operator, - STATE(445), 1, + STATE(474), 1, sym__additive_operator, - STATE(455), 1, + STATE(476), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(711), 2, + STATE(735), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(627), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70257,44 +74864,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36330] = 15, - ACTIONS(373), 1, + [37540] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1071), 1, + aux_sym_object_access_token1, + STATE(738), 1, + aux_sym_object_access_repeat1, + STATE(736), 2, + sym_comment, + sym_include, + ACTIONS(621), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1056), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(712), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(623), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70308,47 +74905,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36396] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [37594] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1058), 1, - sym__terminator, - STATE(443), 1, + STATE(472), 1, sym__logical_operator, - STATE(445), 1, + STATE(474), 1, sym__additive_operator, - STATE(455), 1, + STATE(476), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(713), 2, + STATE(737), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(1119), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70359,44 +74961,33 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36462] = 15, - ACTIONS(373), 1, + [37658] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(1121), 1, + aux_sym_object_access_token1, + ACTIONS(608), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1060), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(714), 2, + STATE(738), 3, sym_comment, sym_include, - ACTIONS(898), 6, + aux_sym_object_access_repeat1, + ACTIONS(610), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70410,47 +75001,52 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36528] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [37710] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1062), 1, - aux_sym_if_statement_token2, - STATE(443), 1, + STATE(472), 1, sym__logical_operator, - STATE(445), 1, + STATE(474), 1, sym__additive_operator, - STATE(455), 1, + STATE(476), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(715), 2, + STATE(739), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(641), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70461,47 +75057,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36594] = 15, - ACTIONS(373), 1, + [37774] = 13, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1064), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, + STATE(472), 1, sym__logical_operator, - STATE(445), 1, + STATE(474), 1, sym__additive_operator, - STATE(455), 1, + STATE(476), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(716), 2, + STATE(740), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(643), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + ACTIONS(631), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70512,44 +75108,33 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36660] = 15, - ACTIONS(373), 1, + [37838] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(554), 1, + anon_sym_LPAREN, + STATE(741), 2, + sym_comment, + sym_include, + ACTIONS(661), 4, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1066), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(717), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + aux_sym_object_access_token1, + ACTIONS(663), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70563,47 +75148,51 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36726] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [37890] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1068), 1, - sym__terminator, - STATE(443), 1, + STATE(472), 1, sym__logical_operator, - STATE(445), 1, + STATE(474), 1, sym__additive_operator, - STATE(455), 1, + STATE(476), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(480), 1, sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(629), 2, + anon_sym_SLASH, + anon_sym_STAR, + ACTIONS(633), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(718), 2, + STATE(742), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(550), 9, + sym_identifier, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_NO_DASHERROR, + ACTIONS(635), 15, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70614,43 +75203,38 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36792] = 11, - ACTIONS(373), 1, + [37952] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, + ACTIONS(1069), 1, sym__namedot, - ACTIONS(490), 1, - aux_sym_object_access_token1, - ACTIONS(1070), 1, - anon_sym_LPAREN, - STATE(275), 1, + STATE(716), 1, aux_sym_qualified_name_repeat1, - STATE(335), 1, - aux_sym_object_access_repeat1, - STATE(719), 2, + STATE(743), 2, sym_comment, sym_include, - ACTIONS(484), 3, + ACTIONS(446), 30, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(486), 22, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70661,47 +75245,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36850] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [38004] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1072), 1, - anon_sym_LPAREN, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(720), 2, + ACTIONS(1077), 1, + aux_sym_object_access_token1, + STATE(766), 1, + aux_sym_object_access_repeat1, + STATE(744), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(621), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70712,44 +75290,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36916] = 15, - ACTIONS(373), 1, + aux_sym_include_argument_token1, + [38053] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + STATE(745), 2, + sym_comment, + sym_include, + ACTIONS(657), 4, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1074), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(721), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + aux_sym_object_access_token1, + ACTIONS(659), 27, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70763,36 +75329,53 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [36982] = 5, - ACTIONS(3), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [38102] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(1076), 1, - anon_sym_NO_DASHERROR, - STATE(722), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(1124), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(746), 2, sym_comment, sym_include, - ACTIONS(472), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -70803,45 +75386,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [37028] = 15, - ACTIONS(373), 1, + [38169] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1078), 1, - anon_sym_COLON, - STATE(378), 1, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, sym__additive_operator, - STATE(382), 1, + STATE(425), 1, sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(723), 2, + ACTIONS(1126), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(747), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70855,44 +75438,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37094] = 15, - ACTIONS(373), 1, + [38236] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1080), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(724), 2, + ACTIONS(1128), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(748), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70906,44 +75490,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37160] = 15, - ACTIONS(373), 1, + [38303] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1082), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(725), 2, + ACTIONS(1130), 2, + sym__terminator, + aux_sym_output_stream_statement_token1, + STATE(749), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -70957,44 +75542,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37226] = 15, - ACTIONS(373), 1, + [38370] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1084), 1, - aux_sym_if_statement_token2, - STATE(443), 1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(726), 2, + ACTIONS(1124), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(750), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71008,44 +75594,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37292] = 15, - ACTIONS(373), 1, + [38437] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1086), 1, - anon_sym_COLON, - STATE(378), 1, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, sym__additive_operator, - STATE(382), 1, + STATE(425), 1, sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(960), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(727), 2, + STATE(751), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71059,44 +75646,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37358] = 15, - ACTIONS(373), 1, + [38504] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1088), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(667), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(728), 2, + STATE(752), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(974), 21, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71110,24 +75694,31 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37424] = 7, - ACTIONS(3), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [38567] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1026), 1, - sym__namedot, - STATE(762), 1, - aux_sym_qualified_name_repeat1, - STATE(729), 2, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + STATE(753), 2, sym_comment, sym_include, - ACTIONS(422), 28, + ACTIONS(625), 3, anon_sym_SLASH, - sym_identifier, - sym__terminator, + anon_sym_LT, + anon_sym_GT, + ACTIONS(978), 24, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -71137,11 +75728,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, - anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71152,45 +75741,42 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [37474] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [38624] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1090), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(637), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(730), 2, + STATE(754), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(980), 23, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71204,44 +75790,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37540] = 15, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [38685] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1092), 1, - anon_sym_COLON, - STATE(378), 1, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, sym__additive_operator, - STATE(382), 1, + STATE(425), 1, sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(731), 2, + ACTIONS(984), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(755), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71255,44 +75844,45 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37606] = 15, - ACTIONS(373), 1, + [38752] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1094), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(732), 2, + ACTIONS(970), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(756), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71306,36 +75896,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37672] = 5, - ACTIONS(3), 1, + [38819] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(1096), 1, - anon_sym_NO_DASHERROR, - STATE(733), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(972), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(757), 2, sym_comment, sym_include, - ACTIONS(888), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71346,27 +75948,78 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [37718] = 4, - ACTIONS(3), 1, + [38886] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(734), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + STATE(407), 1, + sym__comparison_operator, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(976), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(758), 2, sym_comment, sym_include, - ACTIONS(633), 31, - anon_sym_SLASH, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [38953] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, anon_sym_LBRACE, - anon_sym_RBRACE, + STATE(759), 2, + sym_comment, + sym_include, + ACTIONS(657), 31, + anon_sym_SLASH, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -71385,49 +76038,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, aux_sym_object_access_token1, - [37762] = 15, - ACTIONS(373), 1, + aux_sym_widget_field_token1, + [39000] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1098), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(735), 2, + ACTIONS(71), 1, + sym__namedot, + STATE(760), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(69), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71438,44 +76082,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37828] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [39049] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1100), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(736), 2, + STATE(761), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(552), 8, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71489,20 +76136,22 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [37894] = 4, - ACTIONS(3), 1, + [39114] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(737), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(762), 2, sym_comment, sym_include, - ACTIONS(448), 31, + ACTIONS(69), 3, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + anon_sym_LT, + anon_sym_GT, + ACTIONS(71), 28, + sym__namedot, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -71512,11 +76161,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, - anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71527,19 +76174,23 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - aux_sym_object_access_token1, - [37938] = 5, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + anon_sym_BY, + [39163] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(387), 1, + ACTIONS(1132), 1, sym__namedot, - STATE(738), 2, + STATE(763), 3, sym_comment, sym_include, - ACTIONS(385), 30, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 30, anon_sym_SLASH, anon_sym_LBRACE, anon_sym_RBRACE, @@ -71570,47 +76221,38 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, aux_sym_include_argument_token1, - [37984] = 15, - ACTIONS(373), 1, + [39210] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1102), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(739), 2, + ACTIONS(1079), 1, + sym__namedot, + STATE(763), 1, + aux_sym_qualified_name_repeat1, + STATE(764), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(61), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71621,44 +76263,46 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38050] = 15, - ACTIONS(373), 1, + aux_sym_include_argument_token1, + [39259] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1104), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, + STATE(407), 1, sym__comparison_operator, - ACTIONS(625), 2, + STATE(423), 1, + sym__multiplicative_operator, + STATE(424), 1, + sym__additive_operator, + STATE(425), 1, + sym__logical_operator, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(740), 2, + ACTIONS(982), 2, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(765), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -71672,24 +76316,23 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38116] = 7, + [39326] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1024), 1, + ACTIONS(1135), 1, aux_sym_object_access_token1, - STATE(748), 1, - aux_sym_object_access_repeat1, - STATE(741), 2, + STATE(766), 3, sym_comment, sym_include, - ACTIONS(607), 28, + aux_sym_object_access_repeat1, + ACTIONS(608), 30, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -71714,18 +76357,18 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [38166] = 5, + aux_sym_include_argument_token1, + [39373] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(1106), 1, - sym__namedot, - STATE(742), 2, + ACTIONS(1075), 1, + anon_sym_LPAREN, + STATE(767), 2, sym_comment, sym_include, - ACTIONS(412), 30, + ACTIONS(661), 31, anon_sym_SLASH, anon_sym_LBRACE, anon_sym_RBRACE, @@ -71756,47 +76399,39 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, aux_sym_include_argument_token1, - [38212] = 15, - ACTIONS(373), 1, + aux_sym_object_access_token1, + [39420] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1108), 1, - anon_sym_RPAREN, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(743), 2, + ACTIONS(1079), 1, + sym__namedot, + STATE(764), 1, + aux_sym_qualified_name_repeat1, + STATE(768), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(446), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71807,47 +76442,35 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38278] = 15, - ACTIONS(373), 1, + aux_sym_include_argument_token1, + [39469] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1110), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(744), 2, + STATE(769), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(432), 31, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71858,47 +76481,38 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38344] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_object_access_token1, + aux_sym_widget_field_token1, + [39516] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1112), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(745), 2, + STATE(770), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(436), 31, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71909,43 +76523,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38410] = 11, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_object_access_token1, + aux_sym_widget_field_token1, + [39563] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(490), 1, - aux_sym_object_access_token1, - ACTIONS(1114), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(335), 1, - aux_sym_object_access_repeat1, - STATE(746), 2, + ACTIONS(1138), 1, + anon_sym_NO_DASHERROR, + STATE(771), 2, sym_comment, sym_include, - ACTIONS(484), 3, + ACTIONS(540), 30, anon_sym_SLASH, - anon_sym_LT, - anon_sym_GT, - ACTIONS(486), 22, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -71956,47 +76567,41 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38468] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [39612] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1116), 1, - anon_sym_LPAREN, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(747), 2, + ACTIONS(1079), 1, + sym__namedot, + STATE(764), 1, + aux_sym_qualified_name_repeat1, + STATE(772), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(544), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, + sym_identifier, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72007,29 +76612,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38534] = 6, + aux_sym_include_argument_token1, + [39661] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1118), 1, - aux_sym_object_access_token1, - STATE(748), 3, + ACTIONS(1140), 1, + sym__namedot, + STATE(773), 2, sym_comment, sym_include, - aux_sym_object_access_repeat1, - ACTIONS(588), 28, + ACTIONS(422), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -72048,30 +76653,31 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [38582] = 6, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [39710] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1121), 1, - sym__namedot, - STATE(749), 3, + ACTIONS(1142), 1, + anon_sym_NO_DASHERROR, + STATE(774), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 28, + ACTIONS(906), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -72090,45 +76696,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [38630] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [39759] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1124), 1, - sym__terminator, - STATE(443), 1, + ACTIONS(1144), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(750), 2, + STATE(775), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72142,36 +76750,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38696] = 6, - ACTIONS(3), 1, + [39825] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1022), 1, - anon_sym_LPAREN, - STATE(751), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1146), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(776), 2, sym_comment, sym_include, - ACTIONS(611), 29, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72182,32 +76801,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - aux_sym_object_access_token1, - [38744] = 7, + [39891] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1026), 1, - sym__namedot, - STATE(762), 1, - aux_sym_qualified_name_repeat1, - STATE(752), 2, + STATE(777), 2, sym_comment, sym_include, - ACTIONS(426), 28, + ACTIONS(406), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -72226,45 +76839,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [38794] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [39937] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1126), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, + ACTIONS(1148), 1, + sym__terminator, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(753), 2, + STATE(778), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72278,44 +76893,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38860] = 15, - ACTIONS(373), 1, + [40003] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1128), 1, - anon_sym_RPAREN, - STATE(443), 1, + ACTIONS(1150), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(754), 2, + STATE(779), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72329,44 +76944,40 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38926] = 15, - ACTIONS(373), 1, + [40069] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(556), 1, + aux_sym_object_access_token1, + ACTIONS(1152), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(353), 1, + aux_sym_object_access_repeat1, + STATE(780), 2, + sym_comment, + sym_include, + ACTIONS(454), 3, anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1130), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(755), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, + ACTIONS(456), 22, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72380,44 +76991,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [38992] = 15, - ACTIONS(373), 1, + [40127] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1132), 1, + ACTIONS(1154), 1, anon_sym_RPAREN, - STATE(443), 1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(756), 2, + STATE(781), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72431,44 +77042,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39058] = 15, - ACTIONS(373), 1, + [40193] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1134), 1, - aux_sym_else_if_statement_token1, - STATE(443), 1, + ACTIONS(1156), 1, + sym__terminator, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(757), 2, + STATE(782), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72482,44 +77093,44 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39124] = 15, - ACTIONS(373), 1, + [40259] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(619), 1, + ACTIONS(629), 1, anon_sym_SLASH, - ACTIONS(902), 1, + ACTIONS(966), 1, anon_sym_STAR, - ACTIONS(1136), 1, + ACTIONS(1158), 1, sym__terminator, - STATE(443), 1, + STATE(499), 1, sym__logical_operator, - STATE(445), 1, + STATE(503), 1, sym__additive_operator, - STATE(455), 1, + STATE(504), 1, sym__multiplicative_operator, - STATE(459), 1, + STATE(505), 1, sym__comparison_operator, - ACTIONS(625), 2, + ACTIONS(635), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(900), 2, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, - STATE(758), 2, + STATE(783), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, @@ -72533,47 +77144,34 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39190] = 15, - ACTIONS(373), 1, + [40325] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1138), 1, - anon_sym_RPAREN, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(759), 2, + STATE(784), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(466), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72584,26 +77182,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39256] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40371] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(760), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(785), 2, sym_comment, sym_include, - ACTIONS(460), 31, + ACTIONS(482), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -72622,49 +77223,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - aux_sym_object_access_token1, - [39300] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40417] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1140), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(761), 2, + STATE(786), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(486), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72675,30 +77264,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39366] = 7, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40463] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1026), 1, - sym__namedot, - STATE(749), 1, - aux_sym_qualified_name_repeat1, - STATE(762), 2, + STATE(787), 2, sym_comment, sym_include, - ACTIONS(377), 28, + ACTIONS(490), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -72717,99 +77305,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [39416] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40509] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1142), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(763), 2, + STATE(788), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(508), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, - anon_sym_LT_EQ, - anon_sym_LT_GT, - anon_sym_EQ, - anon_sym_GT_EQ, - aux_sym__comparison_operator_token1, - aux_sym__comparison_operator_token2, - aux_sym__comparison_operator_token3, - aux_sym__comparison_operator_token4, - aux_sym__comparison_operator_token5, - aux_sym__comparison_operator_token6, - aux_sym__comparison_operator_token7, - aux_sym__comparison_operator_token8, - aux_sym__comparison_operator_token9, - [39482] = 15, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1144), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, - STATE(764), 2, - sym_comment, - sym_include, - ACTIONS(898), 6, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - ACTIONS(904), 13, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72820,47 +77346,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39548] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40555] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1146), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(765), 2, + STATE(789), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(512), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72871,47 +77387,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39614] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40601] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1148), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(766), 2, + STATE(790), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(516), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72922,47 +77428,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39680] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40647] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1150), 1, - aux_sym_if_statement_token2, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(767), 2, + STATE(791), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(522), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -72973,47 +77469,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39746] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40693] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1152), 1, - anon_sym_RPAREN, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(768), 2, + STATE(792), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(540), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73024,47 +77510,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39812] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40739] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1154), 1, - sym__terminator, - STATE(443), 1, - sym__logical_operator, - STATE(445), 1, - sym__additive_operator, - STATE(455), 1, - sym__multiplicative_operator, - STATE(459), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(769), 2, + STATE(793), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(494), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73075,47 +77551,37 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39878] = 15, - ACTIONS(373), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40785] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(619), 1, - anon_sym_SLASH, - ACTIONS(902), 1, - anon_sym_STAR, - ACTIONS(1156), 1, - anon_sym_COLON, - STATE(378), 1, - sym__additive_operator, - STATE(382), 1, - sym__logical_operator, - STATE(439), 1, - sym__multiplicative_operator, - STATE(470), 1, - sym__comparison_operator, - ACTIONS(625), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(900), 2, - anon_sym_PLUS, - anon_sym_DASH, - STATE(770), 2, + STATE(794), 2, sym_comment, sym_include, - ACTIONS(898), 6, + ACTIONS(446), 30, + anon_sym_SLASH, + sym_identifier, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - ACTIONS(904), 13, + aux_sym_input_expression_token2, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, + anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73126,26 +77592,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [39944] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40831] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(771), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(795), 2, sym_comment, sym_include, - ACTIONS(496), 30, + ACTIONS(462), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73164,27 +77633,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [39987] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40877] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(772), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(796), 2, sym_comment, sym_include, - ACTIONS(426), 30, + ACTIONS(414), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73203,27 +77674,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40030] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40923] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(773), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(797), 2, sym_comment, sym_include, - ACTIONS(400), 30, + ACTIONS(428), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73242,16 +77715,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40073] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [40969] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(774), 2, + ACTIONS(1160), 1, + sym__namedot, + STATE(798), 2, sym_comment, sym_include, - ACTIONS(468), 30, + ACTIONS(422), 30, anon_sym_SLASH, anon_sym_LBRACE, anon_sym_RBRACE, @@ -73282,34 +77759,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, aux_sym_include_argument_token1, - [40116] = 4, - ACTIONS(3), 1, + [41015] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(775), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1162), 1, + anon_sym_RPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(799), 2, sym_comment, sym_include, - ACTIONS(500), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73320,35 +77810,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40159] = 4, - ACTIONS(3), 1, + [41081] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(776), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1164), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(800), 2, sym_comment, sym_include, - ACTIONS(480), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73359,35 +77861,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40202] = 4, - ACTIONS(3), 1, + [41147] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(777), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1166), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(801), 2, sym_comment, sym_include, - ACTIONS(524), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73398,27 +77912,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40245] = 4, + [41213] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(778), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(802), 2, sym_comment, sym_include, - ACTIONS(520), 30, + ACTIONS(504), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73437,37 +77950,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40288] = 6, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [41259] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(387), 1, - sym__namedot, - STATE(779), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1168), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(803), 2, sym_comment, sym_include, - ACTIONS(385), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73478,27 +78004,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [40335] = 4, + [41325] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(780), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(804), 2, sym_comment, sym_include, - ACTIONS(492), 30, + ACTIONS(544), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73517,35 +78042,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40378] = 4, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [41371] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(781), 2, - sym_comment, - sym_include, - ACTIONS(408), 30, - anon_sym_SLASH, + ACTIONS(63), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1170), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(805), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73556,35 +78096,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40421] = 4, - ACTIONS(3), 1, + [41437] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(782), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1172), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(806), 2, sym_comment, sym_include, - ACTIONS(412), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73595,35 +78147,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40464] = 5, - ACTIONS(3), 1, + [41503] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(783), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1174), 1, + anon_sym_RPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(807), 2, sym_comment, sym_include, - ACTIONS(633), 29, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73634,36 +78198,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - aux_sym_object_access_token1, - [40509] = 4, - ACTIONS(3), 1, + [41569] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(784), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1176), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(808), 2, sym_comment, sym_include, - ACTIONS(418), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73674,35 +78249,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40552] = 4, - ACTIONS(3), 1, + [41635] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(785), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1178), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(809), 2, sym_comment, sym_include, - ACTIONS(508), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73713,27 +78300,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40595] = 4, + [41701] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(786), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(810), 2, sym_comment, sym_include, - ACTIONS(392), 30, + ACTIONS(550), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73752,27 +78338,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40638] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [41747] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(787), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(811), 2, sym_comment, sym_include, - ACTIONS(504), 30, + ACTIONS(532), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73791,35 +78379,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40681] = 4, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [41793] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(788), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1180), 1, + anon_sym_LPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(812), 2, sym_comment, sym_include, - ACTIONS(476), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73830,27 +78433,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40724] = 4, + [41859] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(789), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(813), 2, sym_comment, sym_include, - ACTIONS(532), 30, + ACTIONS(402), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -73869,21 +78471,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40767] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [41905] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(790), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1100), 1, + sym__namedot, + STATE(833), 1, + aux_sym_qualified_name_repeat1, + STATE(814), 2, sym_comment, sym_include, - ACTIONS(536), 30, + ACTIONS(61), 28, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -73908,21 +78516,25 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40810] = 4, + anon_sym_NO_DASHERROR, + [41955] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(791), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1098), 1, + aux_sym_object_access_token1, + STATE(834), 1, + aux_sym_object_access_repeat1, + STATE(815), 2, sym_comment, sym_include, - ACTIONS(484), 30, + ACTIONS(621), 28, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -73947,35 +78559,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40853] = 4, - ACTIONS(3), 1, + anon_sym_NO_DASHERROR, + [42005] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(792), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1182), 1, + anon_sym_RPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(816), 2, sym_comment, sym_include, - ACTIONS(540), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -73986,27 +78611,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40896] = 5, + [42071] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(793), 2, + STATE(817), 2, sym_comment, sym_include, - ACTIONS(460), 29, + ACTIONS(442), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74025,28 +78649,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - aux_sym_object_access_token1, - [40941] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42117] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(794), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(818), 2, sym_comment, sym_include, - ACTIONS(528), 30, + ACTIONS(410), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74065,27 +78690,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [40984] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42163] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(795), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(819), 2, sym_comment, sym_include, - ACTIONS(516), 30, + ACTIONS(422), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74104,21 +78731,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41027] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42209] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(796), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1100), 1, + sym__namedot, + STATE(814), 1, + aux_sym_qualified_name_repeat1, + STATE(820), 2, sym_comment, sym_include, - ACTIONS(422), 30, + ACTIONS(446), 28, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, + sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -74143,29 +78776,27 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41070] = 6, + anon_sym_NO_DASHERROR, + [42259] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1158), 1, - sym__namedot, - STATE(797), 2, + STATE(821), 2, sym_comment, sym_include, - ACTIONS(412), 28, + ACTIONS(458), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74184,35 +78815,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41117] = 4, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42305] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(798), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1184), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(822), 2, sym_comment, sym_include, - ACTIONS(404), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74223,35 +78869,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41160] = 4, - ACTIONS(3), 1, + [42371] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(799), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1186), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(823), 2, sym_comment, sym_include, - ACTIONS(472), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74262,27 +78920,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41203] = 5, + [42437] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(800), 2, + STATE(824), 2, sym_comment, sym_include, - ACTIONS(448), 29, + ACTIONS(450), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74301,28 +78958,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - aux_sym_object_access_token1, - [41248] = 4, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42483] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(801), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(825), 2, sym_comment, sym_include, - ACTIONS(396), 30, + ACTIONS(454), 30, anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, sym_identifier, - anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74341,35 +78999,50 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41291] = 4, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42529] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(802), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1188), 1, + anon_sym_RPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(826), 2, sym_comment, sym_include, - ACTIONS(512), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74380,35 +79053,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41334] = 4, - ACTIONS(3), 1, + [42595] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(803), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1190), 1, + anon_sym_LPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(827), 2, sym_comment, sym_include, - ACTIONS(464), 30, - anon_sym_SLASH, - anon_sym_LBRACE, - anon_sym_RBRACE, - sym_identifier, - anon_sym_DQUOTE, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74419,21 +79104,31 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - aux_sym_include_argument_token1, - [41377] = 5, - ACTIONS(3), 1, + [42661] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(804), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(556), 1, + aux_sym_object_access_token1, + ACTIONS(1192), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(353), 1, + aux_sym_object_access_repeat1, + STATE(828), 2, sym_comment, sym_include, - ACTIONS(412), 28, + ACTIONS(454), 3, anon_sym_SLASH, - sym_identifier, - sym__terminator, + anon_sym_LT, + anon_sym_GT, + ACTIONS(456), 22, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -74443,11 +79138,9 @@ static const uint16_t ts_small_parse_table[] = { anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, - anon_sym_LT, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74458,27 +79151,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41421] = 5, + [42719] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(805), 2, + STATE(829), 2, sym_comment, sym_include, - ACTIONS(536), 28, + ACTIONS(418), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74497,27 +79189,29 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41465] = 5, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42765] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(806), 2, + STATE(830), 2, sym_comment, sym_include, - ACTIONS(468), 28, + ACTIONS(498), 30, anon_sym_SLASH, sym_identifier, - sym__terminator, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + aux_sym_input_expression_token2, anon_sym_PLUS, anon_sym_DASH, anon_sym_STAR, @@ -74536,18 +79230,22 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41509] = 5, + anon_sym_COMMA, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [42811] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(807), 2, + ACTIONS(1096), 1, + anon_sym_LPAREN, + STATE(831), 2, sym_comment, sym_include, - ACTIONS(400), 28, + ACTIONS(661), 29, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -74576,34 +79274,48 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [41553] = 5, - ACTIONS(3), 1, + aux_sym_object_access_token1, + [42859] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(808), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1194), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(832), 2, sym_comment, sym_include, - ACTIONS(492), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74614,18 +79326,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41597] = 5, + [42925] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(809), 2, + ACTIONS(1196), 1, + sym__namedot, + STATE(833), 3, sym_comment, sym_include, - ACTIONS(408), 28, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 28, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -74654,17 +79368,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [41641] = 5, + [42973] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(810), 2, + ACTIONS(1199), 1, + aux_sym_object_access_token1, + STATE(834), 3, sym_comment, sym_include, - ACTIONS(476), 28, + aux_sym_object_access_repeat1, + ACTIONS(608), 28, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -74693,76 +79410,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [41685] = 8, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1162), 1, - aux_sym_else_if_statement_token1, - STATE(839), 1, - aux_sym_if_statement_repeat1, - STATE(811), 2, - sym_comment, - sym_include, - STATE(950), 2, - sym_else_if_statement, - sym_else_statement, - ACTIONS(1160), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [41735] = 5, - ACTIONS(3), 1, + [43021] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(812), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1202), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(835), 2, sym_comment, sym_include, - ACTIONS(426), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74773,35 +79461,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41779] = 5, - ACTIONS(3), 1, + [43087] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(813), 2, - sym_comment, - sym_include, - ACTIONS(472), 28, + ACTIONS(629), 1, anon_sym_SLASH, - sym_identifier, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1204), 1, sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(836), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74812,35 +79512,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41823] = 5, - ACTIONS(3), 1, + [43153] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(814), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1206), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(837), 2, sym_comment, sym_include, - ACTIONS(524), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74851,35 +79563,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41867] = 5, - ACTIONS(3), 1, + [43219] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(815), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1208), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(838), 2, sym_comment, sym_include, - ACTIONS(404), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74890,35 +79614,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41911] = 5, - ACTIONS(3), 1, + [43285] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(816), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1210), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(839), 2, sym_comment, sym_include, - ACTIONS(512), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -74929,121 +79665,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [41955] = 9, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1164), 1, - ts_builtin_sym_end, - ACTIONS(1168), 1, - aux_sym_else_if_statement_token1, - STATE(818), 1, - aux_sym_if_statement_repeat1, - STATE(817), 2, - sym_comment, - sym_include, - STATE(998), 2, - sym_else_if_statement, - sym_else_statement, - ACTIONS(1166), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [42007] = 9, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1168), 1, - aux_sym_else_if_statement_token1, - ACTIONS(1170), 1, - ts_builtin_sym_end, - STATE(820), 1, - aux_sym_if_statement_repeat1, - STATE(818), 2, - sym_comment, - sym_include, - STATE(998), 2, - sym_else_if_statement, - sym_else_statement, - ACTIONS(1160), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [42059] = 5, - ACTIONS(3), 1, + [43351] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(819), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1212), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(840), 2, sym_comment, sym_include, - ACTIONS(464), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75054,77 +79716,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42103] = 8, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1172), 1, - ts_builtin_sym_end, - ACTIONS(1176), 1, - aux_sym_else_if_statement_token1, - STATE(998), 2, - sym_else_if_statement, - sym_else_statement, - STATE(820), 3, - sym_comment, - sym_include, - aux_sym_if_statement_repeat1, - ACTIONS(1174), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [42153] = 5, - ACTIONS(3), 1, + [43417] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(821), 2, - sym_comment, - sym_include, - ACTIONS(484), 28, + ACTIONS(629), 1, anon_sym_SLASH, - sym_identifier, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1214), 1, sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(841), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75135,35 +79767,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42197] = 5, - ACTIONS(3), 1, + [43483] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(822), 2, - sym_comment, - sym_include, - ACTIONS(516), 28, + ACTIONS(629), 1, anon_sym_SLASH, - sym_identifier, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1216), 1, sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(842), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75174,35 +79818,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42241] = 5, - ACTIONS(3), 1, + [43549] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(823), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1218), 1, + aux_sym_else_if_statement_token1, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(843), 2, sym_comment, sym_include, - ACTIONS(528), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75213,35 +79869,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42285] = 5, - ACTIONS(3), 1, + [43615] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(824), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1220), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(844), 2, sym_comment, sym_include, - ACTIONS(480), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_STAR, - anon_sym_LT, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75252,35 +79920,47 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42329] = 5, - ACTIONS(3), 1, + [43681] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(825), 2, - sym_comment, - sym_include, - ACTIONS(418), 28, + ACTIONS(629), 1, anon_sym_SLASH, - sym_identifier, - sym__terminator, - aux_sym__logical_operator_token1, - aux_sym__logical_operator_token2, - aux_sym__logical_operator_token3, - aux_sym__logical_operator_token4, - aux_sym__logical_operator_token5, - aux_sym__logical_operator_token6, - anon_sym_PLUS, - anon_sym_DASH, + ACTIONS(966), 1, anon_sym_STAR, - anon_sym_LT, + ACTIONS(1222), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(845), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75291,35 +79971,149 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42373] = 5, - ACTIONS(3), 1, + [43747] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(826), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1224), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(846), 2, sym_comment, sym_include, - ACTIONS(392), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [43813] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1226), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, + STATE(847), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [43879] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, anon_sym_STAR, + ACTIONS(1228), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(848), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75330,35 +80124,149 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42417] = 5, - ACTIONS(3), 1, + [43945] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(827), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1230), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(849), 2, sym_comment, sym_include, - ACTIONS(396), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [44011] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1232), 1, + anon_sym_RPAREN, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, + STATE(850), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [44077] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, anon_sym_STAR, + ACTIONS(1234), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(851), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75369,35 +80277,149 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42461] = 5, - ACTIONS(3), 1, + [44143] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(828), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1236), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(852), 2, sym_comment, sym_include, - ACTIONS(504), 28, - anon_sym_SLASH, - sym_identifier, - sym__terminator, + ACTIONS(962), 6, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, aux_sym__logical_operator_token4, aux_sym__logical_operator_token5, aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [44209] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1238), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, anon_sym_PLUS, anon_sym_DASH, + STATE(853), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [44275] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, anon_sym_STAR, + ACTIONS(1240), 1, + sym__terminator, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(854), 2, + sym_comment, + sym_include, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, anon_sym_LT_EQ, anon_sym_LT_GT, anon_sym_EQ, - anon_sym_GT, anon_sym_GT_EQ, aux_sym__comparison_operator_token1, aux_sym__comparison_operator_token2, @@ -75408,63 +80430,73 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42505] = 8, - ACTIONS(3), 1, + [44341] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1162), 1, - aux_sym_else_if_statement_token1, - STATE(811), 1, - aux_sym_if_statement_repeat1, - STATE(829), 2, + ACTIONS(629), 1, + anon_sym_SLASH, + ACTIONS(966), 1, + anon_sym_STAR, + ACTIONS(1242), 1, + aux_sym_if_statement_token2, + STATE(499), 1, + sym__logical_operator, + STATE(503), 1, + sym__additive_operator, + STATE(504), 1, + sym__multiplicative_operator, + STATE(505), 1, + sym__comparison_operator, + ACTIONS(635), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(964), 2, + anon_sym_PLUS, + anon_sym_DASH, + STATE(855), 2, sym_comment, sym_include, - STATE(950), 2, - sym_else_if_statement, - sym_else_statement, - ACTIONS(1166), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [42555] = 5, + ACTIONS(962), 6, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + ACTIONS(968), 13, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [44407] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(830), 2, + ACTIONS(71), 1, + sym__namedot, + STATE(856), 2, sym_comment, sym_include, - ACTIONS(508), 28, + ACTIONS(69), 30, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75489,20 +80521,22 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42599] = 6, + aux_sym_include_argument_token1, + [44453] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1179), 1, - anon_sym_NO_DASHERROR, - STATE(831), 2, + ACTIONS(1100), 1, + sym__namedot, + STATE(814), 1, + aux_sym_qualified_name_repeat1, + STATE(857), 2, sym_comment, sym_include, - ACTIONS(888), 27, + ACTIONS(544), 28, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -75530,20 +80564,21 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [42645] = 5, + anon_sym_NO_DASHERROR, + [44503] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(832), 2, + STATE(858), 2, sym_comment, sym_include, - ACTIONS(496), 28, + ACTIONS(432), 31, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75568,23 +80603,24 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42689] = 6, + aux_sym_include_argument_token1, + aux_sym_object_access_token1, + [44547] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1181), 1, + ACTIONS(1244), 1, anon_sym_NO_DASHERROR, - STATE(833), 2, + STATE(859), 2, sym_comment, sym_include, - ACTIONS(472), 27, + ACTIONS(540), 30, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75609,20 +80645,23 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - [42735] = 5, + aux_sym_include_argument_token1, + [44593] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(834), 2, + ACTIONS(1246), 1, + anon_sym_NO_DASHERROR, + STATE(860), 2, sym_comment, sym_include, - ACTIONS(422), 28, + ACTIONS(906), 30, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75647,21 +80686,21 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42779] = 5, + aux_sym_include_argument_token1, + [44639] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(835), 2, + STATE(861), 2, sym_comment, sym_include, - ACTIONS(540), 28, + ACTIONS(436), 31, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75686,21 +80725,22 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42823] = 5, + aux_sym_include_argument_token1, + aux_sym_object_access_token1, + [44683] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(836), 2, + STATE(862), 2, sym_comment, sym_include, - ACTIONS(520), 28, + ACTIONS(657), 31, anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - sym__terminator, + anon_sym_DQUOTE, aux_sym__logical_operator_token1, aux_sym__logical_operator_token2, aux_sym__logical_operator_token3, @@ -75725,18 +80765,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token7, aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, - anon_sym_NO_DASHERROR, - [42867] = 5, + aux_sym_include_argument_token1, + aux_sym_object_access_token1, + [44727] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(837), 2, + STATE(863), 2, sym_comment, sym_include, - ACTIONS(532), 28, + ACTIONS(657), 29, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -75765,17 +80806,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [42911] = 5, + aux_sym_object_access_token1, + [44772] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(838), 2, + ACTIONS(71), 1, + sym__namedot, + STATE(864), 2, sym_comment, sym_include, - ACTIONS(500), 28, + ACTIONS(69), 28, anon_sym_SLASH, sym_identifier, sym__terminator, @@ -75804,25 +80848,26 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__comparison_operator_token8, aux_sym__comparison_operator_token9, anon_sym_NO_DASHERROR, - [42955] = 7, + [44819] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1183), 1, + ACTIONS(1248), 1, + ts_builtin_sym_end, + ACTIONS(1252), 1, aux_sym_else_if_statement_token1, - STATE(950), 2, + STATE(1095), 2, sym_else_if_statement, sym_else_statement, - STATE(839), 3, + STATE(865), 3, sym_comment, sym_include, aux_sym_if_statement_repeat1, - ACTIONS(1174), 24, + ACTIONS(1250), 24, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -75834,6 +80879,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -75845,635 +80891,65 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [43003] = 26, - ACTIONS(373), 1, + [44870] = 4, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + STATE(866), 2, + sym_comment, + sym_include, + ACTIONS(458), 30, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1188), 1, - anon_sym_COLON, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1408), 1, - sym_of, - STATE(1420), 1, - sym__pre_tuning, - STATE(1474), 1, - sym_where_clause, - STATE(1494), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1640), 1, - aux_sym_for_phrase_repeat2, - STATE(1906), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1973), 1, - sym_on_quit_phrase, - STATE(2402), 1, - sym_on_stop_phrase, - STATE(2471), 1, - aux_sym_for_statement_repeat1, - STATE(840), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43087] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1198), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1409), 1, - sym_of, - STATE(1411), 1, - sym__pre_tuning, - STATE(1502), 1, - aux_sym_for_phrase_repeat1, - STATE(1513), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1632), 1, - aux_sym_for_phrase_repeat2, - STATE(1848), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2067), 1, - sym_on_quit_phrase, - STATE(2270), 1, - aux_sym_for_statement_repeat1, - STATE(2325), 1, - sym_on_stop_phrase, - STATE(841), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43171] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1200), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1400), 1, - sym_of, - STATE(1431), 1, - sym__pre_tuning, - STATE(1490), 1, - sym_where_clause, - STATE(1495), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1669), 1, - aux_sym_for_phrase_repeat2, - STATE(1908), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1996), 1, - sym_on_quit_phrase, - STATE(2301), 1, - sym_on_stop_phrase, - STATE(2416), 1, - aux_sym_for_statement_repeat1, - STATE(842), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43255] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1202), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1406), 1, - sym_of, - STATE(1422), 1, - sym__pre_tuning, - STATE(1461), 1, - aux_sym_for_phrase_repeat1, - STATE(1473), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1664), 1, - aux_sym_for_phrase_repeat2, - STATE(1924), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1979), 1, - sym_on_quit_phrase, - STATE(2398), 1, - aux_sym_for_statement_repeat1, - STATE(2412), 1, - sym_on_stop_phrase, - STATE(843), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43339] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1204), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1398), 1, - sym_of, - STATE(1423), 1, - sym__pre_tuning, - STATE(1450), 1, - sym_where_clause, - STATE(1454), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1650), 1, - aux_sym_for_phrase_repeat2, - STATE(1882), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2031), 1, - sym_on_quit_phrase, - STATE(2506), 1, - sym_on_stop_phrase, - STATE(2507), 1, - aux_sym_for_statement_repeat1, - STATE(844), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43423] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1206), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1407), 1, - sym_of, - STATE(1419), 1, - sym__pre_tuning, - STATE(1480), 1, - sym_where_clause, - STATE(1493), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1631), 1, - aux_sym_for_phrase_repeat2, - STATE(1837), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2016), 1, - sym_on_quit_phrase, - STATE(2197), 1, - aux_sym_for_statement_repeat1, - STATE(2252), 1, - sym_on_stop_phrase, - STATE(845), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43507] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1208), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1410), 1, - sym_of, - STATE(1413), 1, - sym__pre_tuning, - STATE(1503), 1, - sym_where_clause, - STATE(1515), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1649), 1, - aux_sym_for_phrase_repeat2, - STATE(1880), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2018), 1, - sym_on_quit_phrase, - STATE(2488), 1, - aux_sym_for_statement_repeat1, - STATE(2502), 1, - sym_on_stop_phrase, - STATE(846), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43591] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1210), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1399), 1, - sym_of, - STATE(1418), 1, - sym__pre_tuning, - STATE(1470), 1, - aux_sym_for_phrase_repeat1, - STATE(1472), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1691), 1, - aux_sym_for_phrase_repeat2, - STATE(1943), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2068), 1, - sym_on_quit_phrase, - STATE(2527), 1, - aux_sym_for_statement_repeat1, - STATE(2555), 1, - sym_on_stop_phrase, - STATE(847), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43675] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1212), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1402), 1, - sym_of, - STATE(1427), 1, - sym__pre_tuning, - STATE(1449), 1, - sym_where_clause, - STATE(1455), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1633), 1, - aux_sym_for_phrase_repeat2, - STATE(1918), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1978), 1, - sym_on_quit_phrase, - STATE(2180), 1, - sym_on_stop_phrase, - STATE(2194), 1, - aux_sym_for_statement_repeat1, - STATE(848), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43759] = 26, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1214), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1396), 1, - sym_of, - STATE(1414), 1, - sym__pre_tuning, - STATE(1491), 1, - aux_sym_for_phrase_repeat1, - STATE(1504), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1647), 1, - aux_sym_for_phrase_repeat2, - STATE(1931), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1966), 1, - sym_on_quit_phrase, - STATE(2428), 1, - aux_sym_for_statement_repeat1, - STATE(2459), 1, - sym_on_stop_phrase, - STATE(849), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [43843] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(850), 2, - sym_comment, - sym_include, - ACTIONS(1216), 25, + anon_sym_RBRACE, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [43884] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [44913] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1218), 1, + ACTIONS(1255), 1, ts_builtin_sym_end, - STATE(851), 2, + ACTIONS(1259), 1, + aux_sym_else_if_statement_token1, + STATE(865), 1, + aux_sym_if_statement_repeat1, + STATE(867), 2, sym_comment, sym_include, - ACTIONS(1220), 24, + STATE(1095), 2, + sym_else_if_statement, + sym_else_statement, + ACTIONS(1257), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -76481,12 +80957,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -76498,143 +80974,118 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [43927] = 6, + [44966] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1222), 1, - ts_builtin_sym_end, - STATE(852), 2, + ACTIONS(1261), 1, + sym__namedot, + STATE(868), 2, sym_comment, sym_include, - ACTIONS(1224), 24, + ACTIONS(422), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [43970] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [45013] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(853), 2, + STATE(869), 2, sym_comment, sym_include, - ACTIONS(1228), 24, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44013] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(498), 30, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(854), 2, - sym_comment, - sym_include, - ACTIONS(1228), 24, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44056] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45056] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(855), 2, + ACTIONS(1265), 1, + aux_sym_else_if_statement_token1, + STATE(881), 1, + aux_sym_if_statement_repeat1, + STATE(870), 2, sym_comment, sym_include, - ACTIONS(1228), 24, + STATE(936), 2, + sym_else_if_statement, + sym_else_statement, + ACTIONS(1263), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -76646,439 +81097,428 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [44099] = 6, + [45107] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(856), 2, + STATE(871), 2, sym_comment, sym_include, - ACTIONS(1228), 24, + ACTIONS(406), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44142] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45150] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1230), 1, - ts_builtin_sym_end, - STATE(857), 2, + STATE(872), 2, sym_comment, sym_include, - ACTIONS(1232), 24, + ACTIONS(466), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44185] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45193] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1234), 1, - ts_builtin_sym_end, - STATE(858), 2, + STATE(873), 2, sym_comment, sym_include, - ACTIONS(1236), 24, + ACTIONS(454), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44228] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45236] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(859), 2, + STATE(874), 2, sym_comment, sym_include, - ACTIONS(1240), 24, + ACTIONS(450), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44271] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45279] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(860), 2, + STATE(875), 2, sym_comment, sym_include, - ACTIONS(1240), 24, + ACTIONS(482), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44314] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45322] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(861), 2, + STATE(876), 2, sym_comment, sym_include, - ACTIONS(1240), 24, + ACTIONS(486), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44357] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45365] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(862), 2, + STATE(877), 2, sym_comment, sym_include, - ACTIONS(1240), 24, + ACTIONS(490), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44400] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45408] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(863), 2, + STATE(878), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44443] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(508), 30, + anon_sym_SLASH, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(864), 2, - sym_comment, - sym_include, - ACTIONS(1240), 24, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44486] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45451] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1242), 1, - ts_builtin_sym_end, - STATE(865), 2, + STATE(879), 2, sym_comment, sym_include, - ACTIONS(1244), 24, + ACTIONS(512), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44529] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45494] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1246), 1, - ts_builtin_sym_end, - STATE(866), 2, + STATE(880), 2, sym_comment, sym_include, - ACTIONS(1248), 24, + ACTIONS(516), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44572] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45537] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1250), 1, - ts_builtin_sym_end, - STATE(867), 2, + ACTIONS(1265), 1, + aux_sym_else_if_statement_token1, + STATE(894), 1, + aux_sym_if_statement_repeat1, + STATE(881), 2, sym_comment, sym_include, - ACTIONS(1252), 24, + STATE(936), 2, + sym_else_if_statement, + sym_else_statement, + ACTIONS(1257), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -77090,56 +81530,65 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [44615] = 6, + [45588] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1254), 1, - ts_builtin_sym_end, - STATE(868), 2, + STATE(882), 2, sym_comment, sym_include, - ACTIONS(1256), 24, + ACTIONS(522), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44658] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45631] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1258), 1, + ACTIONS(1259), 1, + aux_sym_else_if_statement_token1, + ACTIONS(1267), 1, ts_builtin_sym_end, - STATE(869), 2, + STATE(867), 1, + aux_sym_if_statement_repeat1, + STATE(883), 2, sym_comment, sym_include, - ACTIONS(1260), 24, + STATE(1095), 2, + sym_else_if_statement, + sym_else_statement, + ACTIONS(1263), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -77147,12 +81596,12 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -77164,401 +81613,427 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [44701] = 6, + [45684] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1258), 1, - ts_builtin_sym_end, - STATE(870), 2, + STATE(884), 2, sym_comment, sym_include, - ACTIONS(1260), 24, + ACTIONS(550), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44744] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45727] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1258), 1, - ts_builtin_sym_end, - STATE(871), 2, + STATE(885), 2, sym_comment, sym_include, - ACTIONS(1260), 24, + ACTIONS(540), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44787] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45770] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1258), 1, - ts_builtin_sym_end, - STATE(872), 2, + STATE(886), 2, sym_comment, sym_include, - ACTIONS(1260), 24, + ACTIONS(494), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44830] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45813] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1262), 1, - ts_builtin_sym_end, - STATE(873), 2, + STATE(887), 2, sym_comment, sym_include, - ACTIONS(1264), 24, + ACTIONS(422), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44873] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45856] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1266), 1, - ts_builtin_sym_end, - STATE(874), 2, + STATE(888), 2, sym_comment, sym_include, - ACTIONS(1268), 24, + ACTIONS(446), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44916] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45899] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1270), 1, - ts_builtin_sym_end, - STATE(875), 2, + STATE(889), 2, sym_comment, sym_include, - ACTIONS(1272), 24, + ACTIONS(410), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [44959] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45942] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1274), 1, - ts_builtin_sym_end, - STATE(876), 2, + STATE(890), 2, sym_comment, sym_include, - ACTIONS(1276), 24, + ACTIONS(442), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45002] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [45985] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1278), 1, - ts_builtin_sym_end, - STATE(877), 2, + STATE(891), 2, sym_comment, sym_include, - ACTIONS(1280), 24, + ACTIONS(462), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45045] = 5, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46028] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(878), 2, + STATE(892), 2, sym_comment, sym_include, - ACTIONS(1282), 25, + ACTIONS(414), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45086] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46071] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(879), 2, + STATE(893), 2, sym_comment, sym_include, - ACTIONS(1220), 24, + ACTIONS(402), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45129] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46114] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(880), 2, + ACTIONS(1269), 1, + aux_sym_else_if_statement_token1, + STATE(936), 2, + sym_else_if_statement, + sym_else_statement, + STATE(894), 3, sym_comment, sym_include, - ACTIONS(1220), 24, + aux_sym_if_statement_repeat1, + ACTIONS(1250), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -77570,1167 +82045,1466 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [45172] = 6, + [46163] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(881), 2, + STATE(895), 2, sym_comment, sym_include, - ACTIONS(1220), 24, + ACTIONS(532), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45215] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46206] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1284), 1, - ts_builtin_sym_end, - STATE(882), 2, + STATE(896), 2, sym_comment, sym_include, - ACTIONS(1286), 24, + ACTIONS(428), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45258] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46249] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1288), 1, - ts_builtin_sym_end, - STATE(883), 2, + STATE(897), 2, sym_comment, sym_include, - ACTIONS(1290), 24, + ACTIONS(436), 29, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45301] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + aux_sym_object_access_token1, + [46294] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(884), 2, + STATE(898), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(432), 29, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45344] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + aux_sym_object_access_token1, + [46339] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(885), 2, + STATE(899), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(418), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45387] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46382] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(886), 2, + STATE(900), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(544), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45430] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46425] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(887), 2, + STATE(901), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(504), 30, + anon_sym_SLASH, + anon_sym_LBRACE, + anon_sym_RBRACE, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45473] = 6, + anon_sym_DQUOTE, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + aux_sym_include_argument_token1, + [46468] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(888), 2, + ACTIONS(1272), 1, + anon_sym_NO_DASHERROR, + STATE(902), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(906), 27, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45516] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [46514] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(889), 2, + STATE(903), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(462), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45559] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46558] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1296), 1, - ts_builtin_sym_end, - STATE(890), 2, + STATE(904), 2, sym_comment, sym_include, - ACTIONS(1298), 24, + ACTIONS(414), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45602] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46602] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1300), 1, - ts_builtin_sym_end, - STATE(891), 2, + STATE(905), 2, sym_comment, sym_include, - ACTIONS(1302), 24, + ACTIONS(494), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45645] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46646] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1304), 1, - ts_builtin_sym_end, - STATE(892), 2, + STATE(906), 2, sym_comment, sym_include, - ACTIONS(1282), 24, + ACTIONS(508), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45688] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46690] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1306), 1, - ts_builtin_sym_end, - STATE(893), 2, + STATE(907), 2, sym_comment, sym_include, - ACTIONS(1308), 24, + ACTIONS(418), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45731] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46734] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1310), 1, - ts_builtin_sym_end, - STATE(894), 2, + STATE(908), 2, sym_comment, sym_include, - ACTIONS(1312), 24, + ACTIONS(402), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45774] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46778] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1314), 1, - ts_builtin_sym_end, - STATE(895), 2, + STATE(909), 2, sym_comment, sym_include, - ACTIONS(1316), 24, + ACTIONS(406), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45817] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46822] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1318), 1, - ts_builtin_sym_end, - STATE(896), 2, + STATE(910), 2, sym_comment, sym_include, - ACTIONS(1320), 24, + ACTIONS(458), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45860] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46866] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(897), 2, + STATE(911), 2, sym_comment, sym_include, - ACTIONS(1324), 24, + ACTIONS(512), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45903] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46910] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(898), 2, + STATE(912), 2, sym_comment, sym_include, - ACTIONS(1324), 24, + ACTIONS(446), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45946] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [46954] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(899), 2, + ACTIONS(1274), 1, + anon_sym_NO_DASHERROR, + STATE(913), 2, sym_comment, sym_include, - ACTIONS(1324), 24, + ACTIONS(540), 27, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [45989] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + [47000] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(900), 2, + STATE(914), 2, sym_comment, sym_include, - ACTIONS(1324), 24, + ACTIONS(544), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46032] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47044] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1326), 1, - ts_builtin_sym_end, - STATE(901), 2, + STATE(915), 2, sym_comment, sym_include, - ACTIONS(1328), 24, + ACTIONS(442), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46075] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1330), 1, - ts_builtin_sym_end, - STATE(902), 2, - sym_comment, - sym_include, - ACTIONS(1332), 24, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46118] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47088] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1334), 1, - ts_builtin_sym_end, - STATE(903), 2, + STATE(916), 2, sym_comment, sym_include, - ACTIONS(1336), 24, + ACTIONS(428), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46161] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47132] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1338), 1, - ts_builtin_sym_end, - STATE(904), 2, + STATE(917), 2, sym_comment, sym_include, - ACTIONS(1340), 24, + ACTIONS(498), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46204] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47176] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1342), 1, - ts_builtin_sym_end, - STATE(905), 2, + STATE(918), 2, sym_comment, sym_include, - ACTIONS(1344), 24, + ACTIONS(550), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46247] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47220] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1346), 1, - ts_builtin_sym_end, - STATE(906), 2, + STATE(919), 2, sym_comment, sym_include, - ACTIONS(1348), 24, + ACTIONS(466), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46290] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47264] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1350), 1, - ts_builtin_sym_end, - STATE(907), 2, + STATE(920), 2, sym_comment, sym_include, - ACTIONS(1352), 24, + ACTIONS(482), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46333] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47308] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1354), 1, - ts_builtin_sym_end, - STATE(908), 2, + STATE(921), 2, sym_comment, sym_include, - ACTIONS(1356), 24, + ACTIONS(486), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46376] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47352] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1358), 1, - ts_builtin_sym_end, - STATE(909), 2, + STATE(922), 2, sym_comment, sym_include, - ACTIONS(1360), 24, + ACTIONS(490), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46419] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47396] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1362), 1, - ts_builtin_sym_end, - STATE(910), 2, + STATE(923), 2, sym_comment, sym_include, - ACTIONS(1364), 24, + ACTIONS(454), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46462] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47440] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1366), 1, - ts_builtin_sym_end, - STATE(911), 2, + STATE(924), 2, sym_comment, sym_include, - ACTIONS(1368), 24, + ACTIONS(450), 28, + anon_sym_SLASH, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_else_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [46505] = 6, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47484] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1370), 1, - ts_builtin_sym_end, - STATE(912), 2, + STATE(925), 2, sym_comment, sym_include, - ACTIONS(1372), 24, + ACTIONS(532), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47528] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(926), 2, + sym_comment, + sym_include, + ACTIONS(540), 28, + anon_sym_SLASH, sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47572] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(927), 2, + sym_comment, + sym_include, + ACTIONS(522), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47616] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(928), 2, + sym_comment, + sym_include, + ACTIONS(516), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47660] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(929), 2, + sym_comment, + sym_include, + ACTIONS(422), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47704] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(930), 2, + sym_comment, + sym_include, + ACTIONS(410), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47748] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(931), 2, + sym_comment, + sym_include, + ACTIONS(504), 28, + anon_sym_SLASH, + sym_identifier, + sym__terminator, + aux_sym__logical_operator_token1, + aux_sym__logical_operator_token2, + aux_sym__logical_operator_token3, + aux_sym__logical_operator_token4, + aux_sym__logical_operator_token5, + aux_sym__logical_operator_token6, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_STAR, + anon_sym_LT, + anon_sym_LT_EQ, + anon_sym_LT_GT, + anon_sym_EQ, + anon_sym_GT, + anon_sym_GT_EQ, + aux_sym__comparison_operator_token1, + aux_sym__comparison_operator_token2, + aux_sym__comparison_operator_token3, + aux_sym__comparison_operator_token4, + aux_sym__comparison_operator_token5, + aux_sym__comparison_operator_token6, + aux_sym__comparison_operator_token7, + aux_sym__comparison_operator_token8, + aux_sym__comparison_operator_token9, + anon_sym_NO_DASHERROR, + [47792] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(932), 2, + sym_comment, + sym_include, + ACTIONS(1276), 26, + sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -78743,6 +83517,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78754,20 +83529,77 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46548] = 6, + [47834] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1280), 1, + anon_sym_COLON, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1490), 1, + sym_of, + STATE(1529), 1, + sym__pre_tuning, + STATE(1601), 1, + aux_sym_for_phrase_repeat1, + STATE(1605), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1849), 1, + aux_sym_for_phrase_repeat2, + STATE(2209), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2230), 1, + sym_on_quit_phrase, + STATE(2646), 1, + sym_on_stop_phrase, + STATE(2677), 1, + aux_sym_for_statement_repeat1, + STATE(933), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [47918] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1374), 1, - ts_builtin_sym_end, - STATE(913), 2, + STATE(934), 2, sym_comment, sym_include, - ACTIONS(1376), 24, + ACTIONS(1290), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -78780,6 +83612,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78791,20 +83624,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46591] = 6, + [47960] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1378), 1, - ts_builtin_sym_end, - STATE(914), 2, + STATE(935), 2, sym_comment, sym_include, - ACTIONS(1380), 24, + ACTIONS(1292), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -78817,6 +83649,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78828,20 +83661,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46634] = 6, + [48002] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1382), 1, - ts_builtin_sym_end, - STATE(915), 2, + STATE(936), 2, sym_comment, sym_include, - ACTIONS(1384), 24, + ACTIONS(1294), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -78854,6 +83686,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78865,19 +83698,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46677] = 6, + [48044] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1386), 1, + ACTIONS(1296), 1, ts_builtin_sym_end, - STATE(916), 2, + STATE(937), 2, sym_comment, sym_include, - ACTIONS(1388), 24, + ACTIONS(1298), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -78891,6 +83724,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78902,19 +83736,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46720] = 6, + [48088] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1390), 1, + ACTIONS(1300), 1, ts_builtin_sym_end, - STATE(917), 2, + STATE(938), 2, sym_comment, sym_include, - ACTIONS(1216), 24, + ACTIONS(1302), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -78928,6 +83762,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78939,19 +83774,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46763] = 6, + [48132] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1392), 1, + ACTIONS(1304), 1, ts_builtin_sym_end, - STATE(918), 2, + STATE(939), 2, sym_comment, sym_include, - ACTIONS(1394), 24, + ACTIONS(1306), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -78965,6 +83800,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -78976,19 +83812,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46806] = 6, + [48176] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1396), 1, + ACTIONS(1308), 1, ts_builtin_sym_end, - STATE(919), 2, + STATE(940), 2, sym_comment, sym_include, - ACTIONS(1398), 24, + ACTIONS(1310), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -79002,6 +83838,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79013,20 +83850,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46849] = 6, + [48220] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1400), 1, - ts_builtin_sym_end, - STATE(920), 2, + STATE(941), 2, sym_comment, sym_include, - ACTIONS(1402), 24, + ACTIONS(1312), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79039,6 +83875,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79050,17 +83887,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46892] = 5, + [48262] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(921), 2, + STATE(942), 2, sym_comment, sym_include, - ACTIONS(1404), 25, + ACTIONS(1314), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -79075,6 +83912,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79086,17 +83924,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46933] = 5, + [48304] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(922), 2, + STATE(943), 2, sym_comment, sym_include, - ACTIONS(1394), 25, + ACTIONS(1316), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -79111,6 +83949,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79122,19 +83961,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [46974] = 5, + [48346] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(923), 2, + ACTIONS(1318), 1, + ts_builtin_sym_end, + STATE(944), 2, sym_comment, sym_include, - ACTIONS(1388), 25, + ACTIONS(1320), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79147,6 +83987,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79158,19 +83999,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47015] = 5, + [48390] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(924), 2, + ACTIONS(1322), 1, + ts_builtin_sym_end, + STATE(945), 2, sym_comment, sym_include, - ACTIONS(1384), 25, + ACTIONS(1324), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79183,6 +84025,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79194,19 +84037,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47056] = 5, + [48434] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(925), 2, + ACTIONS(1326), 1, + ts_builtin_sym_end, + STATE(946), 2, sym_comment, sym_include, - ACTIONS(1316), 25, + ACTIONS(1328), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79219,6 +84063,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79230,19 +84075,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47097] = 5, + [48478] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(926), 2, + ACTIONS(1330), 1, + ts_builtin_sym_end, + STATE(947), 2, sym_comment, sym_include, - ACTIONS(1312), 25, + ACTIONS(1332), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79255,6 +84101,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79266,19 +84113,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47138] = 5, + [48522] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(927), 2, + ACTIONS(1334), 1, + ts_builtin_sym_end, + STATE(948), 2, sym_comment, sym_include, - ACTIONS(1308), 25, + ACTIONS(1336), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79291,6 +84139,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79302,19 +84151,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47179] = 5, + [48566] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(928), 2, + ACTIONS(1338), 1, + ts_builtin_sym_end, + STATE(949), 2, sym_comment, sym_include, - ACTIONS(1402), 25, + ACTIONS(1340), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79327,6 +84177,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79338,19 +84189,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47220] = 6, + [48610] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1406), 1, + ACTIONS(1342), 1, ts_builtin_sym_end, - STATE(929), 2, + STATE(950), 2, sym_comment, sym_include, - ACTIONS(1404), 24, + ACTIONS(1344), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -79364,6 +84215,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79375,19 +84227,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47263] = 5, + [48654] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(930), 2, + ACTIONS(1346), 1, + ts_builtin_sym_end, + STATE(951), 2, sym_comment, sym_include, - ACTIONS(1280), 25, + ACTIONS(1348), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79400,6 +84253,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79411,19 +84265,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47304] = 5, + [48698] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(931), 2, + ACTIONS(1350), 1, + ts_builtin_sym_end, + STATE(952), 2, sym_comment, sym_include, - ACTIONS(1408), 25, + ACTIONS(1352), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79436,6 +84291,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79447,19 +84303,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47345] = 5, + [48742] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(932), 2, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(953), 2, sym_comment, sym_include, - ACTIONS(1276), 25, + ACTIONS(1356), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79472,6 +84329,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79483,19 +84341,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47386] = 5, + [48786] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(933), 2, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(954), 2, sym_comment, sym_include, - ACTIONS(1272), 25, + ACTIONS(1356), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79508,6 +84367,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79519,19 +84379,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47427] = 5, + [48830] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(934), 2, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(955), 2, sym_comment, sym_include, - ACTIONS(1268), 25, + ACTIONS(1356), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79544,6 +84405,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79555,19 +84417,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47468] = 5, + [48874] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(935), 2, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(956), 2, sym_comment, sym_include, - ACTIONS(1264), 25, + ACTIONS(1356), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79580,6 +84443,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79591,19 +84455,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47509] = 5, + [48918] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(936), 2, + ACTIONS(1358), 1, + ts_builtin_sym_end, + STATE(957), 2, sym_comment, sym_include, - ACTIONS(1260), 25, + ACTIONS(1360), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79616,6 +84481,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79627,19 +84493,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47550] = 5, + [48962] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(937), 2, + ACTIONS(1362), 1, + ts_builtin_sym_end, + STATE(958), 2, sym_comment, sym_include, - ACTIONS(1260), 25, + ACTIONS(1364), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79652,6 +84519,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79663,19 +84531,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47591] = 5, + [49006] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(938), 2, + ACTIONS(1366), 1, + ts_builtin_sym_end, + STATE(959), 2, sym_comment, sym_include, - ACTIONS(1260), 25, + ACTIONS(1368), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79688,6 +84557,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79699,19 +84569,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47632] = 5, + [49050] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(939), 2, + ACTIONS(1370), 1, + ts_builtin_sym_end, + STATE(960), 2, sym_comment, sym_include, - ACTIONS(1260), 25, + ACTIONS(1372), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79724,6 +84595,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79735,19 +84607,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47673] = 5, + [49094] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(940), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(961), 2, sym_comment, sym_include, - ACTIONS(1256), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79760,6 +84633,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79771,19 +84645,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47714] = 5, + [49138] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(941), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(962), 2, sym_comment, sym_include, - ACTIONS(1252), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79796,6 +84671,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79807,19 +84683,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47755] = 5, + [49182] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(942), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(963), 2, sym_comment, sym_include, - ACTIONS(1410), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79832,6 +84709,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79843,19 +84721,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47796] = 5, + [49226] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(943), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(964), 2, sym_comment, sym_include, - ACTIONS(1248), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79868,6 +84747,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79879,19 +84759,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47837] = 5, + [49270] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(944), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(965), 2, sym_comment, sym_include, - ACTIONS(1244), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79904,6 +84785,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79915,19 +84797,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47878] = 5, + [49314] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(945), 2, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(966), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1276), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79940,6 +84823,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79951,19 +84835,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47919] = 5, + [49358] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(946), 2, + ACTIONS(1376), 1, + ts_builtin_sym_end, + STATE(967), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1378), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -79976,6 +84861,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -79987,19 +84873,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [47960] = 5, + [49402] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(947), 2, + ACTIONS(1380), 1, + ts_builtin_sym_end, + STATE(968), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1382), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80012,6 +84899,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80023,19 +84911,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48001] = 5, + [49446] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(948), 2, + ACTIONS(1384), 1, + ts_builtin_sym_end, + STATE(969), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1386), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80048,6 +84937,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80059,19 +84949,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48042] = 5, + [49490] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(949), 2, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(970), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1390), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80084,6 +84975,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80095,19 +84987,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48083] = 5, + [49534] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(950), 2, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(971), 2, sym_comment, sym_include, - ACTIONS(1412), 25, + ACTIONS(1390), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80120,6 +85013,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80131,19 +85025,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48124] = 5, + [49578] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(951), 2, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(972), 2, sym_comment, sym_include, - ACTIONS(1240), 25, + ACTIONS(1390), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80156,6 +85051,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80167,19 +85063,78 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48165] = 5, + [49622] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1392), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1493), 1, + sym_of, + STATE(1510), 1, + sym__pre_tuning, + STATE(1558), 1, + sym_where_clause, + STATE(1582), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1882), 1, + aux_sym_for_phrase_repeat2, + STATE(2145), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2260), 1, + sym_on_quit_phrase, + STATE(2614), 1, + aux_sym_for_statement_repeat1, + STATE(2617), 1, + sym_on_stop_phrase, + STATE(973), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [49706] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(952), 2, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(974), 2, sym_comment, sym_include, - ACTIONS(1236), 25, + ACTIONS(1390), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80192,6 +85147,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80203,19 +85159,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48206] = 5, + [49750] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(953), 2, + ACTIONS(1394), 1, + ts_builtin_sym_end, + STATE(975), 2, sym_comment, sym_include, - ACTIONS(1232), 25, + ACTIONS(1396), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80228,6 +85185,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80239,19 +85197,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48247] = 5, + [49794] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(954), 2, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(976), 2, sym_comment, sym_include, - ACTIONS(1228), 25, + ACTIONS(1400), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80264,6 +85223,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80275,19 +85235,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48288] = 5, + [49838] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(955), 2, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(977), 2, sym_comment, sym_include, - ACTIONS(1414), 25, + ACTIONS(1400), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80300,6 +85261,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80311,19 +85273,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48329] = 5, + [49882] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(956), 2, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(978), 2, sym_comment, sym_include, - ACTIONS(1228), 25, + ACTIONS(1400), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80336,6 +85299,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80347,19 +85311,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48370] = 5, + [49926] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(957), 2, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(979), 2, sym_comment, sym_include, - ACTIONS(1416), 25, + ACTIONS(1400), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80372,6 +85337,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80383,19 +85349,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48411] = 5, + [49970] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(958), 2, + ACTIONS(1402), 1, + ts_builtin_sym_end, + STATE(980), 2, sym_comment, sym_include, - ACTIONS(1418), 25, + ACTIONS(1404), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80408,6 +85375,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80419,19 +85387,78 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48452] = 5, + [50014] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1406), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1498), 1, + sym_of, + STATE(1519), 1, + sym__pre_tuning, + STATE(1576), 1, + sym_where_clause, + STATE(1606), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1839), 1, + aux_sym_for_phrase_repeat2, + STATE(2133), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2268), 1, + sym_on_quit_phrase, + STATE(2623), 1, + aux_sym_for_statement_repeat1, + STATE(2626), 1, + sym_on_stop_phrase, + STATE(981), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [50098] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(959), 2, + ACTIONS(1408), 1, + ts_builtin_sym_end, + STATE(982), 2, sym_comment, sym_include, - ACTIONS(1228), 25, + ACTIONS(1410), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80444,6 +85471,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80455,19 +85483,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48493] = 5, + [50142] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(960), 2, + ACTIONS(1412), 1, + ts_builtin_sym_end, + STATE(983), 2, sym_comment, sym_include, - ACTIONS(1228), 25, + ACTIONS(1414), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80480,6 +85509,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80491,19 +85521,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48534] = 5, + [50186] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(961), 2, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(984), 2, sym_comment, sym_include, - ACTIONS(1224), 25, + ACTIONS(1418), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80516,6 +85547,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80527,19 +85559,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48575] = 6, + [50230] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1420), 1, + ACTIONS(1416), 1, ts_builtin_sym_end, - STATE(962), 2, + STATE(985), 2, sym_comment, sym_include, - ACTIONS(1410), 24, + ACTIONS(1418), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -80553,6 +85585,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80564,19 +85597,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48618] = 5, + [50274] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(963), 2, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(986), 2, sym_comment, sym_include, - ACTIONS(1220), 25, + ACTIONS(1418), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80589,6 +85623,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80600,19 +85635,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48659] = 5, + [50318] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(964), 2, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(987), 2, sym_comment, sym_include, - ACTIONS(1220), 25, + ACTIONS(1418), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80625,6 +85661,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80636,19 +85673,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48700] = 5, + [50362] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(965), 2, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(988), 2, sym_comment, sym_include, - ACTIONS(1220), 25, + ACTIONS(1418), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80661,6 +85699,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80672,19 +85711,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48741] = 5, + [50406] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(966), 2, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(989), 2, sym_comment, sym_include, - ACTIONS(1220), 25, + ACTIONS(1418), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80697,6 +85737,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80708,19 +85749,58 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48782] = 5, + [50450] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(967), 2, + ACTIONS(1420), 1, + ts_builtin_sym_end, + STATE(990), 2, sym_comment, sym_include, - ACTIONS(1286), 25, + ACTIONS(1422), 25, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [50494] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1424), 1, + ts_builtin_sym_end, + STATE(991), 2, + sym_comment, + sym_include, + ACTIONS(1426), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80733,6 +85813,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80744,19 +85825,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48823] = 5, + [50538] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(968), 2, + ACTIONS(1428), 1, + ts_builtin_sym_end, + STATE(992), 2, sym_comment, sym_include, - ACTIONS(1290), 25, + ACTIONS(1430), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80769,6 +85851,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80780,19 +85863,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48864] = 5, + [50582] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(969), 2, + ACTIONS(1432), 1, + ts_builtin_sym_end, + STATE(993), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1434), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80805,6 +85889,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80816,19 +85901,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48905] = 5, + [50626] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(970), 2, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(994), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1438), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80841,6 +85927,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80852,19 +85939,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48946] = 5, + [50670] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(971), 2, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(995), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1438), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80877,6 +85965,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80888,19 +85977,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [48987] = 5, + [50714] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(972), 2, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(996), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1438), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80913,6 +86003,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80924,19 +86015,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49028] = 5, + [50758] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(973), 2, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(997), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1438), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80949,6 +86041,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80960,19 +86053,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49069] = 5, + [50802] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(974), 2, + ACTIONS(1440), 1, + ts_builtin_sym_end, + STATE(998), 2, sym_comment, sym_include, - ACTIONS(1294), 25, + ACTIONS(1442), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -80985,6 +86079,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -80996,19 +86091,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49110] = 5, + [50846] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(975), 2, + ACTIONS(1444), 1, + ts_builtin_sym_end, + STATE(999), 2, sym_comment, sym_include, - ACTIONS(1298), 25, + ACTIONS(1446), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81021,6 +86117,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81032,19 +86129,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49151] = 5, + [50890] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(976), 2, + ACTIONS(1448), 1, + ts_builtin_sym_end, + STATE(1000), 2, sym_comment, sym_include, - ACTIONS(1302), 25, + ACTIONS(1450), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81057,6 +86155,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81068,19 +86167,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49192] = 5, + [50934] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(977), 2, + ACTIONS(1452), 1, + ts_builtin_sym_end, + STATE(1001), 2, sym_comment, sym_include, - ACTIONS(1320), 25, + ACTIONS(1454), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81093,6 +86193,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81104,74 +86205,96 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49233] = 24, - ACTIONS(373), 1, + [50978] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1190), 1, + ACTIONS(1456), 1, + ts_builtin_sym_end, + STATE(1002), 2, + sym_comment, + sym_include, + ACTIONS(1458), 25, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1412), 1, - sym_of, - STATE(1433), 1, - sym__pre_tuning, - STATE(1523), 1, - aux_sym_for_phrase_repeat1, - STATE(1526), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1693), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2048), 1, - sym_on_error_phrase, - STATE(2084), 1, - sym_on_quit_phrase, - STATE(2902), 1, - sym_on_stop_phrase, - ACTIONS(1422), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(978), 2, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [51022] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1460), 1, + ts_builtin_sym_end, + STATE(1003), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [49312] = 5, + ACTIONS(1462), 25, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [51066] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(979), 2, + ACTIONS(1464), 1, + ts_builtin_sym_end, + STATE(1004), 2, sym_comment, sym_include, - ACTIONS(1324), 25, + ACTIONS(1466), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81184,6 +86307,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81195,19 +86319,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49353] = 5, + [51110] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(980), 2, + ACTIONS(1468), 1, + ts_builtin_sym_end, + STATE(1005), 2, sym_comment, sym_include, - ACTIONS(1324), 25, + ACTIONS(1470), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81220,6 +86345,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81231,19 +86357,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49394] = 5, + [51154] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(981), 2, + ACTIONS(1472), 1, + ts_builtin_sym_end, + STATE(1006), 2, sym_comment, sym_include, - ACTIONS(1324), 25, + ACTIONS(1474), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81256,6 +86383,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81267,19 +86395,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49435] = 5, + [51198] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(982), 2, + ACTIONS(1476), 1, + ts_builtin_sym_end, + STATE(1007), 2, sym_comment, sym_include, - ACTIONS(1324), 25, + ACTIONS(1478), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81292,6 +86421,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81303,19 +86433,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49476] = 5, + [51242] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(983), 2, + ACTIONS(1480), 1, + ts_builtin_sym_end, + STATE(1008), 2, sym_comment, sym_include, - ACTIONS(1328), 25, + ACTIONS(1482), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81328,6 +86459,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81339,19 +86471,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49517] = 5, + [51286] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(984), 2, + ACTIONS(1484), 1, + ts_builtin_sym_end, + STATE(1009), 2, sym_comment, sym_include, - ACTIONS(1332), 25, + ACTIONS(1486), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81364,6 +86497,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81375,19 +86509,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49558] = 5, + [51330] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(985), 2, + ACTIONS(1488), 1, + ts_builtin_sym_end, + STATE(1010), 2, sym_comment, sym_include, - ACTIONS(1336), 25, + ACTIONS(1490), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81400,6 +86535,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81411,19 +86547,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49599] = 5, + [51374] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(986), 2, + ACTIONS(1492), 1, + ts_builtin_sym_end, + STATE(1011), 2, sym_comment, sym_include, - ACTIONS(1340), 25, + ACTIONS(1494), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81436,6 +86573,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81447,19 +86585,78 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49640] = 5, + [51418] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1496), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1497), 1, + sym_of, + STATE(1534), 1, + sym__pre_tuning, + STATE(1595), 1, + sym_where_clause, + STATE(1599), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1820), 1, + aux_sym_for_phrase_repeat2, + STATE(2132), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2304), 1, + sym_on_quit_phrase, + STATE(2682), 1, + aux_sym_for_statement_repeat1, + STATE(2686), 1, + sym_on_stop_phrase, + STATE(1012), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [51502] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(987), 2, + ACTIONS(1498), 1, + ts_builtin_sym_end, + STATE(1013), 2, sym_comment, sym_include, - ACTIONS(1344), 25, + ACTIONS(1500), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81472,6 +86669,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81483,19 +86681,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49681] = 5, + [51546] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(988), 2, + ACTIONS(1502), 1, + ts_builtin_sym_end, + STATE(1014), 2, sym_comment, sym_include, - ACTIONS(1348), 25, + ACTIONS(1504), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81508,6 +86707,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81519,19 +86719,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49722] = 5, + [51590] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(989), 2, + ACTIONS(1506), 1, + ts_builtin_sym_end, + STATE(1015), 2, sym_comment, sym_include, - ACTIONS(1352), 25, + ACTIONS(1508), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81544,6 +86745,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81555,19 +86757,20 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49763] = 5, + [51634] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(990), 2, + ACTIONS(1510), 1, + ts_builtin_sym_end, + STATE(1016), 2, sym_comment, sym_include, - ACTIONS(1356), 25, + ACTIONS(1512), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81580,6 +86783,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81591,17 +86795,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49804] = 5, + [51678] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(991), 2, + STATE(1017), 2, sym_comment, sym_include, - ACTIONS(1360), 25, + ACTIONS(1298), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81616,6 +86820,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81627,17 +86832,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49845] = 5, + [51720] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(992), 2, + STATE(1018), 2, sym_comment, sym_include, - ACTIONS(1364), 25, + ACTIONS(1302), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81652,6 +86857,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81663,17 +86869,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49886] = 5, + [51762] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(993), 2, + STATE(1019), 2, sym_comment, sym_include, - ACTIONS(1368), 25, + ACTIONS(1306), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81688,6 +86894,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81699,17 +86906,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49927] = 5, + [51804] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(994), 2, + STATE(1020), 2, sym_comment, sym_include, - ACTIONS(1372), 25, + ACTIONS(1310), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81724,6 +86931,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81735,19 +86943,78 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [49968] = 5, + [51846] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1514), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1499), 1, + sym_of, + STATE(1540), 1, + sym__pre_tuning, + STATE(1588), 1, + sym_where_clause, + STATE(1589), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1884), 1, + aux_sym_for_phrase_repeat2, + STATE(2141), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2317), 1, + sym_on_quit_phrase, + STATE(2706), 1, + aux_sym_for_statement_repeat1, + STATE(2707), 1, + sym_on_stop_phrase, + STATE(1021), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [51930] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(995), 2, + ACTIONS(1516), 1, + ts_builtin_sym_end, + STATE(1022), 2, sym_comment, sym_include, - ACTIONS(1376), 25, + ACTIONS(1292), 25, sym_identifier, - aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81760,6 +87027,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81771,17 +87039,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50009] = 5, + [51974] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(996), 2, + STATE(1023), 2, sym_comment, sym_include, - ACTIONS(1380), 25, + ACTIONS(1320), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81796,6 +87064,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81807,17 +87076,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50050] = 5, + [52016] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(997), 2, + STATE(1024), 2, sym_comment, sym_include, - ACTIONS(1398), 25, + ACTIONS(1324), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -81832,6 +87101,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81843,20 +87113,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50091] = 6, + [52058] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1424), 1, - ts_builtin_sym_end, - STATE(998), 2, + STATE(1025), 2, sym_comment, sym_include, - ACTIONS(1412), 24, + ACTIONS(1328), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81869,6 +87138,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81880,20 +87150,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50134] = 6, + [52100] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1426), 1, - ts_builtin_sym_end, - STATE(999), 2, + STATE(1026), 2, sym_comment, sym_include, - ACTIONS(1418), 24, + ACTIONS(1332), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81906,6 +87175,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81917,20 +87187,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50177] = 6, + [52142] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1428), 1, - ts_builtin_sym_end, - STATE(1000), 2, + STATE(1027), 2, sym_comment, sym_include, - ACTIONS(1414), 24, + ACTIONS(1336), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81943,6 +87212,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81954,20 +87224,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50220] = 6, + [52184] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1430), 1, - ts_builtin_sym_end, - STATE(1001), 2, + STATE(1028), 2, sym_comment, sym_include, - ACTIONS(1416), 24, + ACTIONS(1340), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -81980,6 +87249,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -81991,20 +87261,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50263] = 6, + [52226] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1432), 1, - ts_builtin_sym_end, - STATE(1002), 2, + STATE(1029), 2, sym_comment, sym_include, - ACTIONS(1408), 24, + ACTIONS(1344), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -82017,6 +87286,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82028,31 +87298,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50306] = 6, + [52268] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1284), 1, - ts_builtin_sym_end, - STATE(1003), 2, + STATE(1030), 2, sym_comment, sym_include, - ACTIONS(1286), 23, + ACTIONS(1348), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82064,17 +87335,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50348] = 5, + [52310] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1004), 2, + STATE(1031), 2, sym_comment, sym_include, - ACTIONS(1294), 24, + ACTIONS(1352), 26, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -82083,11 +87354,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82099,31 +87372,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50388] = 6, + [52352] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1246), 1, - ts_builtin_sym_end, - STATE(1005), 2, + STATE(1032), 2, sym_comment, sym_include, - ACTIONS(1248), 23, + ACTIONS(1356), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82135,31 +87409,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50430] = 6, + [52394] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1434), 1, - ts_builtin_sym_end, - STATE(1006), 2, + STATE(1033), 2, sym_comment, sym_include, - ACTIONS(1436), 23, + ACTIONS(1356), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82171,31 +87446,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50472] = 6, + [52436] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1438), 1, - ts_builtin_sym_end, - STATE(1007), 2, + STATE(1034), 2, sym_comment, sym_include, - ACTIONS(1440), 23, + ACTIONS(1356), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82207,31 +87483,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50514] = 6, + [52478] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(1008), 2, + STATE(1035), 2, sym_comment, sym_include, - ACTIONS(1324), 23, + ACTIONS(1356), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82243,31 +87520,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50556] = 6, + [52520] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(1009), 2, + STATE(1036), 2, sym_comment, sym_include, - ACTIONS(1324), 23, + ACTIONS(1360), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82279,31 +87557,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50598] = 6, + [52562] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1442), 1, - ts_builtin_sym_end, - STATE(1010), 2, + STATE(1037), 2, sym_comment, sym_include, - ACTIONS(1444), 23, + ACTIONS(1364), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82315,31 +87594,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50640] = 6, + [52604] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(1011), 2, + STATE(1038), 2, sym_comment, sym_include, - ACTIONS(1324), 23, + ACTIONS(1368), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82351,31 +87631,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50682] = 6, + [52646] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1322), 1, - ts_builtin_sym_end, - STATE(1012), 2, + STATE(1039), 2, sym_comment, sym_include, - ACTIONS(1324), 23, + ACTIONS(1372), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82387,31 +87668,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50724] = 6, + [52688] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1326), 1, - ts_builtin_sym_end, - STATE(1013), 2, + STATE(1040), 2, sym_comment, sym_include, - ACTIONS(1328), 23, + ACTIONS(1276), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82423,31 +87705,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50766] = 6, + [52730] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1446), 1, - ts_builtin_sym_end, - STATE(1014), 2, + STATE(1041), 2, sym_comment, sym_include, - ACTIONS(1448), 23, + ACTIONS(1276), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82459,134 +87742,69 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50808] = 24, - ACTIONS(373), 1, + [52772] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1198), 1, - anon_sym_COLON, - STATE(1409), 1, - sym_of, - STATE(1411), 1, - sym__pre_tuning, - STATE(1502), 1, - aux_sym_for_phrase_repeat1, - STATE(1513), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1632), 1, - aux_sym_for_phrase_repeat2, - STATE(1848), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2067), 1, - sym_on_quit_phrase, - STATE(2270), 1, - aux_sym_for_statement_repeat1, - STATE(2325), 1, - sym_on_stop_phrase, - STATE(1015), 2, + STATE(1042), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [50886] = 19, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1450), 1, + ACTIONS(1276), 26, + sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, - ACTIONS(1458), 1, - aux_sym_variable_definition_token3, - ACTIONS(1460), 1, - aux_sym_variable_definition_token4, - ACTIONS(1462), 1, - aux_sym_buffer_definition_token1, - ACTIONS(1464), 1, - aux_sym_buffer_definition_token3, - ACTIONS(1466), 1, - aux_sym_query_definition_token1, - ACTIONS(1470), 1, - aux_sym_stream_definition_token1, - STATE(1534), 1, - aux_sym_variable_definition_repeat1, - STATE(1604), 1, - aux_sym_buffer_definition_repeat1, - STATE(1605), 1, - sym_serialization_tuning, - ACTIONS(1456), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - STATE(1016), 2, - sym_comment, - sym_include, - STATE(1571), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - ACTIONS(1468), 3, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, + aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [50954] = 6, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [52814] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1472), 1, - ts_builtin_sym_end, - STATE(1017), 2, + STATE(1043), 2, sym_comment, sym_include, - ACTIONS(1474), 23, + ACTIONS(1276), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82598,31 +87816,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [50996] = 6, + [52856] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1476), 1, - ts_builtin_sym_end, - STATE(1018), 2, + STATE(1044), 2, sym_comment, sym_include, - ACTIONS(1478), 23, + ACTIONS(1276), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82634,31 +87853,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51038] = 6, + [52898] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1480), 1, - ts_builtin_sym_end, - STATE(1019), 2, + STATE(1045), 2, sym_comment, sym_include, - ACTIONS(1482), 23, + ACTIONS(1378), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82670,85 +87890,69 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51080] = 24, - ACTIONS(373), 1, + [52940] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1208), 1, - anon_sym_COLON, - STATE(1410), 1, - sym_of, - STATE(1413), 1, - sym__pre_tuning, - STATE(1503), 1, - sym_where_clause, - STATE(1515), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1649), 1, - aux_sym_for_phrase_repeat2, - STATE(1880), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2018), 1, - sym_on_quit_phrase, - STATE(2488), 1, - aux_sym_for_statement_repeat1, - STATE(2502), 1, - sym_on_stop_phrase, - STATE(1020), 2, + STATE(1046), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [51158] = 6, + ACTIONS(1382), 26, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [52982] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1484), 1, - ts_builtin_sym_end, - STATE(1021), 2, + STATE(1047), 2, sym_comment, sym_include, - ACTIONS(1486), 23, + ACTIONS(1386), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82760,31 +87964,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51200] = 6, + [53024] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1488), 1, - ts_builtin_sym_end, - STATE(1022), 2, + STATE(1048), 2, sym_comment, sym_include, - ACTIONS(1490), 23, + ACTIONS(1390), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82796,31 +88001,90 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51242] = 6, + [53066] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1518), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1502), 1, + sym_of, + STATE(1520), 1, + sym__pre_tuning, + STATE(1562), 1, + aux_sym_for_phrase_repeat1, + STATE(1563), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1827), 1, + aux_sym_for_phrase_repeat2, + STATE(2167), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2354), 1, + sym_on_quit_phrase, + STATE(2762), 1, + aux_sym_for_statement_repeat1, + STATE(2766), 1, + sym_on_stop_phrase, + STATE(1049), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [53150] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1492), 1, - ts_builtin_sym_end, - STATE(1023), 2, + STATE(1050), 2, sym_comment, sym_include, - ACTIONS(1494), 23, + ACTIONS(1390), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82832,31 +88096,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51284] = 6, + [53192] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1496), 1, - ts_builtin_sym_end, - STATE(1024), 2, + STATE(1051), 2, sym_comment, sym_include, - ACTIONS(1498), 23, + ACTIONS(1390), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82868,31 +88133,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51326] = 6, + [53234] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1500), 1, - ts_builtin_sym_end, - STATE(1025), 2, + STATE(1052), 2, sym_comment, sym_include, - ACTIONS(1502), 23, + ACTIONS(1390), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82904,31 +88170,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51368] = 6, + [53276] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1504), 1, - ts_builtin_sym_end, - STATE(1026), 2, + STATE(1053), 2, sym_comment, sym_include, - ACTIONS(1506), 23, + ACTIONS(1396), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82940,31 +88207,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51410] = 6, + [53318] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1508), 1, - ts_builtin_sym_end, - STATE(1027), 2, + STATE(1054), 2, sym_comment, sym_include, - ACTIONS(1510), 23, + ACTIONS(1400), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -82976,31 +88244,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51452] = 6, + [53360] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1512), 1, - ts_builtin_sym_end, - STATE(1028), 2, + STATE(1055), 2, sym_comment, sym_include, - ACTIONS(1514), 23, + ACTIONS(1400), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83012,31 +88281,90 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51494] = 6, + [53402] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1520), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1494), 1, + sym_of, + STATE(1543), 1, + sym__pre_tuning, + STATE(1566), 1, + aux_sym_for_phrase_repeat1, + STATE(1568), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1837), 1, + aux_sym_for_phrase_repeat2, + STATE(2176), 1, + sym_on_error_phrase, + STATE(2223), 1, + sym_on_quit_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2776), 1, + aux_sym_for_statement_repeat1, + STATE(2778), 1, + sym_on_stop_phrase, + STATE(1056), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [53486] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1242), 1, - ts_builtin_sym_end, - STATE(1029), 2, + STATE(1057), 2, sym_comment, sym_include, - ACTIONS(1244), 23, + ACTIONS(1400), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83048,31 +88376,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51536] = 6, + [53528] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1516), 1, - ts_builtin_sym_end, - STATE(1030), 2, + STATE(1058), 2, sym_comment, sym_include, - ACTIONS(1518), 23, + ACTIONS(1400), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83084,31 +88413,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51578] = 6, + [53570] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1520), 1, - ts_builtin_sym_end, - STATE(1031), 2, + STATE(1059), 2, sym_comment, sym_include, - ACTIONS(1522), 23, + ACTIONS(1404), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83120,31 +88450,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51620] = 6, + [53612] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1330), 1, - ts_builtin_sym_end, - STATE(1032), 2, + STATE(1060), 2, sym_comment, sym_include, - ACTIONS(1332), 23, + ACTIONS(1410), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83156,31 +88487,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51662] = 6, + [53654] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1524), 1, - ts_builtin_sym_end, - STATE(1033), 2, + STATE(1061), 2, sym_comment, sym_include, - ACTIONS(1526), 23, + ACTIONS(1414), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83192,31 +88524,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51704] = 6, + [53696] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1528), 1, - ts_builtin_sym_end, - STATE(1034), 2, + STATE(1062), 2, sym_comment, sym_include, - ACTIONS(1530), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83228,31 +88561,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51746] = 6, + [53738] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1532), 1, - ts_builtin_sym_end, - STATE(1035), 2, + STATE(1063), 2, sym_comment, sym_include, - ACTIONS(1534), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83264,31 +88598,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51788] = 6, + [53780] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1536), 1, - ts_builtin_sym_end, - STATE(1036), 2, + STATE(1064), 2, sym_comment, sym_include, - ACTIONS(1538), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83300,31 +88635,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51830] = 6, + [53822] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1540), 1, - ts_builtin_sym_end, - STATE(1037), 2, + STATE(1065), 2, sym_comment, sym_include, - ACTIONS(1542), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83336,31 +88672,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51872] = 6, + [53864] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1544), 1, - ts_builtin_sym_end, - STATE(1038), 2, + STATE(1066), 2, sym_comment, sym_include, - ACTIONS(1546), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83372,31 +88709,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51914] = 6, + [53906] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1548), 1, - ts_builtin_sym_end, - STATE(1039), 2, + STATE(1067), 2, sym_comment, sym_include, - ACTIONS(1550), 23, + ACTIONS(1418), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83408,31 +88746,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51956] = 6, + [53948] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1552), 1, - ts_builtin_sym_end, - STATE(1040), 2, + STATE(1068), 2, sym_comment, sym_include, - ACTIONS(1554), 23, + ACTIONS(1422), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83444,31 +88783,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [51998] = 6, + [53990] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1556), 1, - ts_builtin_sym_end, - STATE(1041), 2, + STATE(1069), 2, sym_comment, sym_include, - ACTIONS(1558), 23, + ACTIONS(1426), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83480,31 +88820,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52040] = 6, + [54032] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1250), 1, - ts_builtin_sym_end, - STATE(1042), 2, + STATE(1070), 2, sym_comment, sym_include, - ACTIONS(1252), 23, + ACTIONS(1430), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83516,31 +88857,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52082] = 6, + [54074] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1043), 2, + STATE(1071), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1434), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83552,31 +88894,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52124] = 6, + [54116] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1560), 1, - ts_builtin_sym_end, - STATE(1044), 2, + STATE(1072), 2, sym_comment, sym_include, - ACTIONS(1562), 23, + ACTIONS(1438), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83588,31 +88931,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52166] = 6, + [54158] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1564), 1, - ts_builtin_sym_end, - STATE(1045), 2, + STATE(1073), 2, sym_comment, sym_include, - ACTIONS(1566), 23, + ACTIONS(1438), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83624,31 +88968,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52208] = 6, + [54200] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1046), 2, + STATE(1074), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1438), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83660,31 +89005,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52250] = 6, + [54242] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1568), 1, - ts_builtin_sym_end, - STATE(1047), 2, + STATE(1075), 2, sym_comment, sym_include, - ACTIONS(1570), 23, + ACTIONS(1438), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83696,31 +89042,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52292] = 6, + [54284] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1572), 1, - ts_builtin_sym_end, - STATE(1048), 2, + STATE(1076), 2, sym_comment, sym_include, - ACTIONS(1574), 23, + ACTIONS(1442), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83732,70 +89079,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52334] = 9, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1560), 1, - ts_builtin_sym_end, - ACTIONS(1576), 1, - aux_sym_buffer_definition_token2, - ACTIONS(1578), 1, - aux_sym_repeat_statement_token1, - ACTIONS(1580), 1, - aux_sym_do_while_statement_token1, - STATE(1049), 2, - sym_comment, - sym_include, - ACTIONS(1562), 20, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [52382] = 6, + [54326] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1334), 1, - ts_builtin_sym_end, - STATE(1050), 2, + STATE(1077), 2, sym_comment, sym_include, - ACTIONS(1336), 23, + ACTIONS(1446), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83807,85 +89116,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52424] = 24, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1210), 1, - anon_sym_COLON, - STATE(1399), 1, - sym_of, - STATE(1418), 1, - sym__pre_tuning, - STATE(1470), 1, - aux_sym_for_phrase_repeat1, - STATE(1472), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1691), 1, - aux_sym_for_phrase_repeat2, - STATE(1943), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2068), 1, - sym_on_quit_phrase, - STATE(2527), 1, - aux_sym_for_statement_repeat1, - STATE(2555), 1, - sym_on_stop_phrase, - STATE(1051), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [52502] = 6, + [54368] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1582), 1, - ts_builtin_sym_end, - STATE(1052), 2, + STATE(1078), 2, sym_comment, sym_include, - ACTIONS(1584), 23, + ACTIONS(1450), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83897,31 +89153,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52544] = 6, + [54410] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1053), 2, + STATE(1079), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1454), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83933,31 +89190,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52586] = 6, + [54452] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1586), 1, - ts_builtin_sym_end, - STATE(1054), 2, + STATE(1080), 2, sym_comment, sym_include, - ACTIONS(1588), 23, + ACTIONS(1458), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -83969,31 +89227,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52628] = 6, + [54494] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1590), 1, - ts_builtin_sym_end, - STATE(1055), 2, + STATE(1081), 2, sym_comment, sym_include, - ACTIONS(1592), 23, + ACTIONS(1462), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84005,31 +89264,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52670] = 6, + [54536] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1594), 1, - ts_builtin_sym_end, - STATE(1056), 2, + STATE(1082), 2, sym_comment, sym_include, - ACTIONS(1596), 23, + ACTIONS(1466), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84041,31 +89301,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52712] = 6, + [54578] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1338), 1, - ts_builtin_sym_end, - STATE(1057), 2, + STATE(1083), 2, sym_comment, sym_include, - ACTIONS(1340), 23, + ACTIONS(1470), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84077,67 +89338,90 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52754] = 6, - ACTIONS(3), 1, + [54620] = 26, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1598), 1, - ts_builtin_sym_end, - STATE(1058), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1522), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1491), 1, + sym_of, + STATE(1542), 1, + sym__pre_tuning, + STATE(1581), 1, + aux_sym_for_phrase_repeat1, + STATE(1584), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1879), 1, + aux_sym_for_phrase_repeat2, + STATE(2204), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2305), 1, + sym_on_quit_phrase, + STATE(2843), 1, + aux_sym_for_statement_repeat1, + STATE(2845), 1, + sym_on_stop_phrase, + STATE(1084), 2, sym_comment, sym_include, - ACTIONS(1600), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [52796] = 6, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [54704] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1602), 1, - ts_builtin_sym_end, - STATE(1059), 2, + STATE(1085), 2, sym_comment, sym_include, - ACTIONS(1604), 23, + ACTIONS(1474), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84149,31 +89433,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52838] = 6, + [54746] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1060), 2, + STATE(1086), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1478), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84185,31 +89470,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52880] = 6, + [54788] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1606), 1, - ts_builtin_sym_end, - STATE(1061), 2, + STATE(1087), 2, sym_comment, sym_include, - ACTIONS(1608), 23, + ACTIONS(1482), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84221,31 +89507,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52922] = 6, + [54830] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1406), 1, - ts_builtin_sym_end, - STATE(1062), 2, + STATE(1088), 2, sym_comment, sym_include, - ACTIONS(1404), 23, + ACTIONS(1486), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84257,85 +89544,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [52964] = 24, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1202), 1, - anon_sym_COLON, - STATE(1406), 1, - sym_of, - STATE(1422), 1, - sym__pre_tuning, - STATE(1461), 1, - aux_sym_for_phrase_repeat1, - STATE(1473), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1664), 1, - aux_sym_for_phrase_repeat2, - STATE(1924), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1979), 1, - sym_on_quit_phrase, - STATE(2398), 1, - aux_sym_for_statement_repeat1, - STATE(2412), 1, - sym_on_stop_phrase, - STATE(1063), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [53042] = 6, + [54872] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1064), 2, + STATE(1089), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1490), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84347,31 +89581,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53084] = 6, + [54914] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1238), 1, - ts_builtin_sym_end, - STATE(1065), 2, + STATE(1090), 2, sym_comment, sym_include, - ACTIONS(1240), 23, + ACTIONS(1494), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84383,31 +89618,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53126] = 6, + [54956] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1234), 1, - ts_builtin_sym_end, - STATE(1066), 2, + STATE(1091), 2, sym_comment, sym_include, - ACTIONS(1236), 23, + ACTIONS(1500), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84419,31 +89655,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53168] = 6, + [54998] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1342), 1, - ts_builtin_sym_end, - STATE(1067), 2, + STATE(1092), 2, sym_comment, sym_include, - ACTIONS(1344), 23, + ACTIONS(1504), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84455,31 +89692,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53210] = 6, + [55040] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1610), 1, - ts_builtin_sym_end, - STATE(1068), 2, + STATE(1093), 2, sym_comment, sym_include, - ACTIONS(1612), 23, + ACTIONS(1508), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84491,31 +89729,32 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53252] = 6, + [55082] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1614), 1, - ts_builtin_sym_end, - STATE(1069), 2, + STATE(1094), 2, sym_comment, sym_include, - ACTIONS(1616), 23, + ACTIONS(1512), 26, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84527,19 +89766,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53294] = 6, + [55124] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1618), 1, + ACTIONS(1524), 1, ts_builtin_sym_end, - STATE(1070), 2, + STATE(1095), 2, sym_comment, sym_include, - ACTIONS(1620), 23, + ACTIONS(1294), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84547,11 +89786,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84563,19 +89804,77 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53336] = 6, + [55168] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1526), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1496), 1, + sym_of, + STATE(1517), 1, + sym__pre_tuning, + STATE(1602), 1, + sym_where_clause, + STATE(1608), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1799), 1, + aux_sym_for_phrase_repeat2, + STATE(2146), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2228), 1, + sym_on_quit_phrase, + STATE(2570), 1, + aux_sym_for_statement_repeat1, + STATE(2583), 1, + sym_on_stop_phrase, + STATE(1096), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [55252] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1622), 1, + ACTIONS(1528), 1, ts_builtin_sym_end, - STATE(1071), 2, + STATE(1097), 2, sym_comment, sym_include, - ACTIONS(1624), 23, + ACTIONS(1316), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84583,11 +89882,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84599,19 +89900,77 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53378] = 6, + [55296] = 26, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1530), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1489), 1, + sym_of, + STATE(1535), 1, + sym__pre_tuning, + STATE(1591), 1, + aux_sym_for_phrase_repeat1, + STATE(1594), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1867), 1, + aux_sym_for_phrase_repeat2, + STATE(2216), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2299), 1, + sym_on_quit_phrase, + STATE(2860), 1, + aux_sym_for_statement_repeat1, + STATE(2868), 1, + sym_on_stop_phrase, + STATE(1098), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [55380] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1254), 1, + ACTIONS(1532), 1, ts_builtin_sym_end, - STATE(1072), 2, + STATE(1099), 2, sym_comment, sym_include, - ACTIONS(1256), 23, + ACTIONS(1314), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84619,11 +89978,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84635,19 +89996,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53420] = 6, + [55424] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1626), 1, + ACTIONS(1534), 1, ts_builtin_sym_end, - STATE(1073), 2, + STATE(1100), 2, sym_comment, sym_include, - ACTIONS(1628), 23, + ACTIONS(1290), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84655,11 +90016,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84671,19 +90034,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53462] = 6, + [55468] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1630), 1, + ACTIONS(1536), 1, ts_builtin_sym_end, - STATE(1074), 2, + STATE(1101), 2, sym_comment, sym_include, - ACTIONS(1632), 23, + ACTIONS(1312), 25, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84691,11 +90054,13 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_else_if_statement_token1, aux_sym_repeat_statement_token1, aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84707,69 +90072,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53504] = 19, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1634), 1, - aux_sym_input_expression_token1, - ACTIONS(1636), 1, - aux_sym_variable_definition_token3, - ACTIONS(1638), 1, - aux_sym_variable_definition_token4, - ACTIONS(1640), 1, - aux_sym_buffer_definition_token1, - ACTIONS(1642), 1, - aux_sym_buffer_definition_token3, - ACTIONS(1644), 1, - aux_sym_query_definition_token1, - ACTIONS(1648), 1, - aux_sym_stream_definition_token1, - STATE(1539), 1, - aux_sym_variable_definition_repeat1, - STATE(1598), 1, - aux_sym_buffer_definition_repeat1, - STATE(1605), 1, - sym_serialization_tuning, - ACTIONS(1456), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - STATE(1075), 2, - sym_comment, - sym_include, - STATE(1571), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - ACTIONS(1646), 3, - aux_sym_argument_mode_token1, - aux_sym_argument_mode_token2, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [53572] = 6, + [55512] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1258), 1, - ts_builtin_sym_end, - STATE(1076), 2, + STATE(1102), 2, sym_comment, sym_include, - ACTIONS(1260), 23, + ACTIONS(1538), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -84781,6 +90096,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84792,19 +90108,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53614] = 6, + [55553] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1650), 1, + ACTIONS(1416), 1, ts_builtin_sym_end, - STATE(1077), 2, + STATE(1103), 2, sym_comment, sym_include, - ACTIONS(1652), 23, + ACTIONS(1418), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84817,6 +90133,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84828,19 +90145,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53656] = 6, + [55596] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1654), 1, + ACTIONS(1440), 1, ts_builtin_sym_end, - STATE(1078), 2, + STATE(1104), 2, sym_comment, sym_include, - ACTIONS(1656), 23, + ACTIONS(1442), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84853,6 +90170,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84864,19 +90182,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53698] = 6, + [55639] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1658), 1, + ACTIONS(1300), 1, ts_builtin_sym_end, - STATE(1079), 2, + STATE(1105), 2, sym_comment, sym_include, - ACTIONS(1660), 23, + ACTIONS(1302), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84889,6 +90207,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84900,19 +90219,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53740] = 6, + [55682] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1346), 1, + ACTIONS(1408), 1, ts_builtin_sym_end, - STATE(1080), 2, + STATE(1106), 2, sym_comment, sym_include, - ACTIONS(1348), 23, + ACTIONS(1410), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -84925,6 +90244,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84936,20 +90256,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53782] = 6, + [55725] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1662), 1, - ts_builtin_sym_end, - STATE(1081), 2, + STATE(1107), 2, sym_comment, sym_include, - ACTIONS(1664), 23, + ACTIONS(1462), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -84961,6 +90280,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -84972,20 +90292,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53824] = 6, + [55766] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1258), 1, - ts_builtin_sym_end, - STATE(1082), 2, + STATE(1108), 2, sym_comment, sym_include, - ACTIONS(1260), 23, + ACTIONS(1540), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -84997,6 +90316,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85008,19 +90328,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53866] = 6, + [55807] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1666), 1, + ACTIONS(1542), 1, ts_builtin_sym_end, - STATE(1083), 2, + STATE(1109), 2, sym_comment, sym_include, - ACTIONS(1668), 23, + ACTIONS(1544), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85033,6 +90353,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85044,19 +90365,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53908] = 6, + [55850] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1662), 1, + ACTIONS(1304), 1, ts_builtin_sym_end, - STATE(1084), 2, + STATE(1110), 2, sym_comment, sym_include, - ACTIONS(1664), 23, + ACTIONS(1306), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85069,6 +90390,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85080,19 +90402,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53950] = 6, + [55893] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1670), 1, + ACTIONS(1308), 1, ts_builtin_sym_end, - STATE(1085), 2, + STATE(1111), 2, sym_comment, sym_include, - ACTIONS(1672), 23, + ACTIONS(1310), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85105,6 +90427,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85116,19 +90439,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [53992] = 6, + [55936] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1258), 1, + ACTIONS(1546), 1, ts_builtin_sym_end, - STATE(1086), 2, + STATE(1112), 2, sym_comment, sym_include, - ACTIONS(1260), 23, + ACTIONS(1548), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85141,6 +90464,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85152,19 +90476,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54034] = 6, + [55979] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1674), 1, + ACTIONS(1550), 1, ts_builtin_sym_end, - STATE(1087), 2, + STATE(1113), 2, sym_comment, sym_include, - ACTIONS(1676), 23, + ACTIONS(1552), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85177,6 +90501,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85188,19 +90513,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54076] = 6, + [56022] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1678), 1, + ACTIONS(1554), 1, ts_builtin_sym_end, - STATE(1088), 2, + STATE(1114), 2, sym_comment, sym_include, - ACTIONS(1680), 23, + ACTIONS(1556), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85213,6 +90538,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85224,20 +90550,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54118] = 6, + [56065] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1682), 1, - ts_builtin_sym_end, - STATE(1089), 2, + STATE(1115), 2, sym_comment, sym_include, - ACTIONS(1684), 23, + ACTIONS(1558), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85249,6 +90574,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85260,20 +90586,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54160] = 6, + [56106] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1686), 1, - ts_builtin_sym_end, - STATE(1090), 2, + STATE(1116), 2, sym_comment, sym_include, - ACTIONS(1688), 23, + ACTIONS(1458), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85285,6 +90610,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85296,20 +90622,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54202] = 6, + [56147] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1690), 1, - ts_builtin_sym_end, - STATE(1091), 2, + STATE(1117), 2, sym_comment, sym_include, - ACTIONS(1692), 23, + ACTIONS(1454), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85321,6 +90646,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85332,20 +90658,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54244] = 6, + [56188] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1694), 1, - ts_builtin_sym_end, - STATE(1092), 2, + STATE(1118), 2, sym_comment, sym_include, - ACTIONS(1696), 23, + ACTIONS(1450), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85357,6 +90682,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85368,19 +90694,55 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54286] = 6, + [56229] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1258), 1, + STATE(1119), 2, + sym_comment, + sym_include, + ACTIONS(1560), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [56270] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1318), 1, ts_builtin_sym_end, - STATE(1093), 2, + STATE(1120), 2, sym_comment, sym_include, - ACTIONS(1260), 23, + ACTIONS(1320), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85393,6 +90755,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85404,19 +90767,91 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54328] = 6, + [56313] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1350), 1, + STATE(1121), 2, + sym_comment, + sym_include, + ACTIONS(1562), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [56354] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1122), 2, + sym_comment, + sym_include, + ACTIONS(1564), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [56395] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1444), 1, ts_builtin_sym_end, - STATE(1094), 2, + STATE(1123), 2, sym_comment, sym_include, - ACTIONS(1352), 23, + ACTIONS(1446), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85429,6 +90864,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85440,19 +90876,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54370] = 6, + [56438] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1698), 1, + ACTIONS(1566), 1, ts_builtin_sym_end, - STATE(1095), 2, + STATE(1124), 2, sym_comment, sym_include, - ACTIONS(1700), 23, + ACTIONS(1568), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85465,6 +90901,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85476,19 +90913,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54412] = 6, + [56481] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1702), 1, + ACTIONS(1402), 1, ts_builtin_sym_end, - STATE(1096), 2, + STATE(1125), 2, sym_comment, sym_include, - ACTIONS(1704), 23, + ACTIONS(1404), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85501,6 +90938,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85512,73 +90950,91 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54454] = 24, - ACTIONS(373), 1, + [56524] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + STATE(1126), 2, + sym_comment, + sym_include, + ACTIONS(1570), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1206), 1, - anon_sym_COLON, - STATE(1407), 1, - sym_of, - STATE(1419), 1, - sym__pre_tuning, - STATE(1480), 1, - sym_where_clause, - STATE(1493), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1631), 1, - aux_sym_for_phrase_repeat2, - STATE(1837), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2016), 1, - sym_on_quit_phrase, - STATE(2197), 1, - aux_sym_for_statement_repeat1, - STATE(2252), 1, - sym_on_stop_phrase, - STATE(1097), 2, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [56565] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1127), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [54532] = 6, + ACTIONS(1446), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [56606] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1278), 1, + ACTIONS(1572), 1, ts_builtin_sym_end, - STATE(1098), 2, + STATE(1128), 2, sym_comment, sym_include, - ACTIONS(1280), 23, + ACTIONS(1574), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85591,6 +91047,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85602,20 +91059,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54574] = 6, + [56649] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1706), 1, - ts_builtin_sym_end, - STATE(1099), 2, + STATE(1129), 2, sym_comment, sym_include, - ACTIONS(1708), 23, + ACTIONS(1556), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85627,6 +91083,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85638,19 +91095,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54616] = 6, + [56690] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1274), 1, + ACTIONS(1576), 1, ts_builtin_sym_end, - STATE(1100), 2, + STATE(1130), 2, sym_comment, sym_include, - ACTIONS(1276), 23, + ACTIONS(1570), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85663,6 +91120,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85674,19 +91132,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54658] = 6, + [56733] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1354), 1, + ACTIONS(1322), 1, ts_builtin_sym_end, - STATE(1101), 2, + STATE(1131), 2, sym_comment, sym_include, - ACTIONS(1356), 23, + ACTIONS(1324), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85699,6 +91157,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85710,20 +91169,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54700] = 6, + [56776] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1310), 1, - ts_builtin_sym_end, - STATE(1102), 2, + STATE(1132), 2, sym_comment, sym_include, - ACTIONS(1312), 23, + ACTIONS(1552), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85735,6 +91193,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85746,19 +91205,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54742] = 6, + [56817] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1262), 1, + ACTIONS(1326), 1, ts_builtin_sym_end, - STATE(1103), 2, + STATE(1133), 2, sym_comment, sym_include, - ACTIONS(1264), 23, + ACTIONS(1328), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85771,6 +91230,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85782,19 +91242,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54784] = 6, + [56860] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1710), 1, + ACTIONS(1398), 1, ts_builtin_sym_end, - STATE(1104), 2, + STATE(1134), 2, sym_comment, sym_include, - ACTIONS(1712), 23, + ACTIONS(1400), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85807,6 +91267,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85818,19 +91279,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54826] = 6, + [56903] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1714), 1, + ACTIONS(1330), 1, ts_builtin_sym_end, - STATE(1105), 2, + STATE(1135), 2, sym_comment, sym_include, - ACTIONS(1716), 23, + ACTIONS(1332), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85843,6 +91304,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85854,20 +91316,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54868] = 6, + [56946] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1230), 1, - ts_builtin_sym_end, - STATE(1106), 2, + STATE(1136), 2, sym_comment, sym_include, - ACTIONS(1232), 23, + ACTIONS(1548), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85879,6 +91340,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85890,19 +91352,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54910] = 6, + [56987] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1718), 1, + ACTIONS(1578), 1, ts_builtin_sym_end, - STATE(1107), 2, + STATE(1137), 2, sym_comment, sym_include, - ACTIONS(1720), 23, + ACTIONS(1580), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -85915,6 +91377,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85926,20 +91389,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54952] = 6, + [57030] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1722), 1, - ts_builtin_sym_end, - STATE(1108), 2, + STATE(1138), 2, sym_comment, sym_include, - ACTIONS(1724), 23, + ACTIONS(1442), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85951,6 +91413,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85962,20 +91425,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [54994] = 6, + [57071] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1270), 1, - ts_builtin_sym_end, - STATE(1109), 2, + STATE(1139), 2, sym_comment, sym_include, - ACTIONS(1272), 23, + ACTIONS(1438), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -85987,6 +91449,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -85998,19 +91461,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55036] = 6, + [57112] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1226), 1, + ACTIONS(1582), 1, ts_builtin_sym_end, - STATE(1110), 2, + STATE(1140), 2, sym_comment, sym_include, - ACTIONS(1228), 23, + ACTIONS(1584), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86023,6 +91486,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86034,19 +91498,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55078] = 6, + [57155] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1358), 1, + ACTIONS(1586), 1, ts_builtin_sym_end, - STATE(1111), 2, + STATE(1141), 2, sym_comment, sym_include, - ACTIONS(1360), 23, + ACTIONS(1588), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86059,6 +91523,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86070,19 +91535,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55120] = 6, + [57198] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1726), 1, + ACTIONS(1590), 1, ts_builtin_sym_end, - STATE(1112), 2, + STATE(1142), 2, sym_comment, sym_include, - ACTIONS(1728), 23, + ACTIONS(1592), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86095,6 +91560,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86106,20 +91572,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55162] = 6, + [57241] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1318), 1, - ts_builtin_sym_end, - STATE(1113), 2, + STATE(1143), 2, sym_comment, sym_include, - ACTIONS(1320), 23, + ACTIONS(1438), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86131,6 +91596,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86142,19 +91608,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55204] = 6, + [57282] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1226), 1, + ACTIONS(1594), 1, ts_builtin_sym_end, - STATE(1114), 2, + STATE(1144), 2, sym_comment, sym_include, - ACTIONS(1228), 23, + ACTIONS(1596), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86167,6 +91633,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86178,19 +91645,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55246] = 6, + [57325] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1362), 1, + ACTIONS(1598), 1, ts_builtin_sym_end, - STATE(1115), 2, + STATE(1145), 2, sym_comment, sym_include, - ACTIONS(1364), 23, + ACTIONS(1600), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86203,6 +91670,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86214,20 +91682,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55288] = 6, + [57368] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1730), 1, - ts_builtin_sym_end, - STATE(1116), 2, + STATE(1146), 2, sym_comment, sym_include, - ACTIONS(1732), 23, + ACTIONS(1438), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86239,6 +91706,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86250,20 +91718,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55330] = 6, + [57409] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1734), 1, - ts_builtin_sym_end, - STATE(1117), 2, + STATE(1147), 2, sym_comment, sym_include, - ACTIONS(1736), 23, + ACTIONS(1438), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86275,6 +91742,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86286,74 +91754,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55372] = 24, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1214), 1, - anon_sym_COLON, - STATE(1396), 1, - sym_of, - STATE(1414), 1, - sym__pre_tuning, - STATE(1491), 1, - aux_sym_for_phrase_repeat1, - STATE(1504), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1647), 1, - aux_sym_for_phrase_repeat2, - STATE(1931), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1966), 1, - sym_on_quit_phrase, - STATE(2428), 1, - aux_sym_for_statement_repeat1, - STATE(2459), 1, - sym_on_stop_phrase, - STATE(1118), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [55450] = 6, + [57450] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(1119), 2, + STATE(1148), 2, sym_comment, sym_include, - ACTIONS(1228), 23, + ACTIONS(1434), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86365,6 +91778,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86376,20 +91790,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55492] = 6, + [57491] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1226), 1, - ts_builtin_sym_end, - STATE(1120), 2, + STATE(1149), 2, sym_comment, sym_include, - ACTIONS(1228), 23, + ACTIONS(1602), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86401,6 +91814,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86412,19 +91826,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55534] = 6, + [57532] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1738), 1, + ACTIONS(1604), 1, ts_builtin_sym_end, - STATE(1121), 2, + STATE(1150), 2, sym_comment, sym_include, - ACTIONS(1740), 23, + ACTIONS(1606), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86437,6 +91851,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86448,19 +91863,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55576] = 6, + [57575] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1366), 1, + ACTIONS(1334), 1, ts_builtin_sym_end, - STATE(1122), 2, + STATE(1151), 2, sym_comment, sym_include, - ACTIONS(1368), 23, + ACTIONS(1336), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86473,6 +91888,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86484,19 +91900,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55618] = 6, + [57618] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1742), 1, + ACTIONS(1338), 1, ts_builtin_sym_end, - STATE(1123), 2, + STATE(1152), 2, sym_comment, sym_include, - ACTIONS(1744), 23, + ACTIONS(1340), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86509,6 +91925,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86520,20 +91937,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55660] = 6, + [57661] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1746), 1, - ts_builtin_sym_end, - STATE(1124), 2, + STATE(1153), 2, sym_comment, sym_include, - ACTIONS(1748), 23, + ACTIONS(1608), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86545,6 +91961,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86556,19 +91973,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55702] = 6, + [57702] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1370), 1, + ACTIONS(1342), 1, ts_builtin_sym_end, - STATE(1125), 2, + STATE(1154), 2, sym_comment, sym_include, - ACTIONS(1372), 23, + ACTIONS(1344), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86581,6 +91998,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86592,19 +92010,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55744] = 6, + [57745] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1750), 1, + ACTIONS(1346), 1, ts_builtin_sym_end, - STATE(1126), 2, + STATE(1155), 2, sym_comment, sym_include, - ACTIONS(1752), 23, + ACTIONS(1348), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86617,6 +92035,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86628,20 +92047,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55786] = 6, + [57788] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1754), 1, - ts_builtin_sym_end, - STATE(1127), 2, + STATE(1156), 2, sym_comment, sym_include, - ACTIONS(1756), 23, + ACTIONS(1610), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86653,6 +92071,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86664,19 +92083,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55828] = 6, + [57829] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1758), 1, + ACTIONS(1612), 1, ts_builtin_sym_end, - STATE(1128), 2, + STATE(1157), 2, sym_comment, sym_include, - ACTIONS(1760), 23, + ACTIONS(1614), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86689,6 +92108,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86700,19 +92120,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55870] = 6, + [57872] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1762), 1, + ACTIONS(1616), 1, ts_builtin_sym_end, - STATE(1129), 2, + STATE(1158), 2, sym_comment, sym_include, - ACTIONS(1764), 23, + ACTIONS(1538), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86725,6 +92145,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86736,20 +92157,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55912] = 6, + [57915] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1374), 1, - ts_builtin_sym_end, - STATE(1130), 2, + STATE(1159), 2, sym_comment, sym_include, - ACTIONS(1376), 23, + ACTIONS(1618), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86761,6 +92181,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86772,20 +92193,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55954] = 6, + [57956] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1766), 1, - ts_builtin_sym_end, - STATE(1131), 2, + STATE(1160), 2, sym_comment, sym_include, - ACTIONS(1768), 23, + ACTIONS(1620), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86797,6 +92217,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86808,56 +92229,60 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [55996] = 6, + [57997] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1378), 1, - ts_builtin_sym_end, - STATE(1132), 2, + ACTIONS(1622), 1, + sym_identifier, + STATE(1505), 1, + sym_access_tuning, + STATE(3483), 1, + sym_primitive_type, + STATE(3612), 1, + sym_qualified_name, + STATE(1161), 2, sym_comment, sym_include, - ACTIONS(1380), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56038] = 6, + ACTIONS(1626), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(1624), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [58048] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1770), 1, - ts_builtin_sym_end, - STATE(1133), 2, + STATE(1162), 2, sym_comment, sym_include, - ACTIONS(1772), 23, + ACTIONS(1628), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -86869,6 +92294,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86880,19 +92306,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56080] = 6, + [58089] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1774), 1, + ACTIONS(1630), 1, ts_builtin_sym_end, - STATE(1134), 2, + STATE(1163), 2, sym_comment, sym_include, - ACTIONS(1776), 23, + ACTIONS(1632), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86905,6 +92331,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86916,19 +92343,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56122] = 6, + [58132] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1390), 1, + ACTIONS(1634), 1, ts_builtin_sym_end, - STATE(1135), 2, + STATE(1164), 2, sym_comment, sym_include, - ACTIONS(1216), 23, + ACTIONS(1636), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86941,6 +92368,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86952,19 +92380,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56164] = 6, + [58175] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1396), 1, + ACTIONS(1638), 1, ts_builtin_sym_end, - STATE(1136), 2, + STATE(1165), 2, sym_comment, sym_include, - ACTIONS(1398), 23, + ACTIONS(1640), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -86977,6 +92405,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -86988,19 +92417,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56206] = 6, + [58218] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1778), 1, + ACTIONS(1388), 1, ts_builtin_sym_end, - STATE(1137), 2, + STATE(1166), 2, sym_comment, sym_include, - ACTIONS(1780), 23, + ACTIONS(1390), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -87013,6 +92442,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87024,19 +92454,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56248] = 6, + [58261] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1400), 1, + ACTIONS(1642), 1, ts_builtin_sym_end, - STATE(1138), 2, + STATE(1167), 2, sym_comment, sym_include, - ACTIONS(1402), 23, + ACTIONS(1564), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -87049,6 +92479,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87060,17 +92491,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56290] = 5, + [58304] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1139), 2, + STATE(1168), 2, sym_comment, sym_include, - ACTIONS(1562), 24, + ACTIONS(1644), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -87084,6 +92515,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87095,33 +92527,179 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56330] = 8, + [58345] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1782), 1, + ACTIONS(1646), 1, + ts_builtin_sym_end, + STATE(1169), 2, + sym_comment, + sym_include, + ACTIONS(1562), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, aux_sym_buffer_definition_token2, - ACTIONS(1784), 1, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, aux_sym_repeat_statement_token1, - ACTIONS(1786), 1, aux_sym_do_while_statement_token1, - STATE(1140), 2, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58388] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1648), 1, + ts_builtin_sym_end, + STATE(1170), 2, + sym_comment, + sym_include, + ACTIONS(1560), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58431] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1650), 1, + ts_builtin_sym_end, + STATE(1171), 2, + sym_comment, + sym_include, + ACTIONS(1652), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58474] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1448), 1, + ts_builtin_sym_end, + STATE(1172), 2, + sym_comment, + sym_include, + ACTIONS(1450), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58517] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1173), 2, sym_comment, sym_include, - ACTIONS(1562), 21, + ACTIONS(1654), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, aux_sym_argument_mode_token1, aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87133,17 +92711,128 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56376] = 5, + [58558] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1141), 2, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(1174), 2, sym_comment, sym_include, - ACTIONS(1588), 24, + ACTIONS(1400), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58601] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1656), 1, + ts_builtin_sym_end, + STATE(1175), 2, + sym_comment, + sym_include, + ACTIONS(1658), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58644] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1660), 1, + ts_builtin_sym_end, + STATE(1176), 2, + sym_comment, + sym_include, + ACTIONS(1662), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58687] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1177), 2, + sym_comment, + sym_include, + ACTIONS(1664), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -87157,6 +92846,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87168,17 +92858,165 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56416] = 5, + [58728] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1142), 2, + ACTIONS(1666), 1, + ts_builtin_sym_end, + STATE(1178), 2, sym_comment, sym_include, - ACTIONS(1592), 24, + ACTIONS(1668), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58771] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1452), 1, + ts_builtin_sym_end, + STATE(1179), 2, + sym_comment, + sym_include, + ACTIONS(1454), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58814] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1456), 1, + ts_builtin_sym_end, + STATE(1180), 2, + sym_comment, + sym_include, + ACTIONS(1458), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58857] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1670), 1, + ts_builtin_sym_end, + STATE(1181), 2, + sym_comment, + sym_include, + ACTIONS(1558), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [58900] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1182), 2, + sym_comment, + sym_include, + ACTIONS(1672), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -87192,6 +93030,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87203,17 +93042,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56456] = 5, + [58941] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1143), 2, + STATE(1183), 2, sym_comment, sym_include, - ACTIONS(1604), 24, + ACTIONS(1430), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -87227,6 +93066,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87238,19 +93078,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56496] = 6, + [58982] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1222), 1, + ACTIONS(1674), 1, ts_builtin_sym_end, - STATE(1144), 2, + STATE(1184), 2, sym_comment, sym_include, - ACTIONS(1224), 23, + ACTIONS(1540), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -87263,6 +93103,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87274,17 +93115,17 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56538] = 5, + [59025] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1145), 2, + STATE(1185), 2, sym_comment, sym_include, - ACTIONS(1404), 24, + ACTIONS(1426), 25, sym_identifier, aux_sym__block_terminator_token1, aux_sym_input_expression_token1, @@ -87298,6 +93139,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87309,19 +93151,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56578] = 6, + [59066] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1788), 1, + ACTIONS(1676), 1, ts_builtin_sym_end, - STATE(1146), 2, + STATE(1186), 2, sym_comment, sym_include, - ACTIONS(1790), 23, + ACTIONS(1678), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -87334,6 +93176,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87345,19 +93188,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56620] = 6, + [59109] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1266), 1, + ACTIONS(1680), 1, ts_builtin_sym_end, - STATE(1147), 2, + STATE(1187), 2, sym_comment, sym_include, - ACTIONS(1268), 23, + ACTIONS(1682), 24, sym_identifier, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, @@ -87370,6 +93213,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87381,20 +93225,19 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56662] = 6, + [59152] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1314), 1, - ts_builtin_sym_end, - STATE(1148), 2, + STATE(1188), 2, sym_comment, sym_include, - ACTIONS(1316), 23, + ACTIONS(1422), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -87406,6 +93249,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87417,20 +93261,128 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56704] = 6, + [59193] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1218), 1, + STATE(1189), 2, + sym_comment, + sym_include, + ACTIONS(1684), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59234] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1460), 1, ts_builtin_sym_end, - STATE(1149), 2, + STATE(1190), 2, + sym_comment, + sym_include, + ACTIONS(1462), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59277] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1191), 2, + sym_comment, + sym_include, + ACTIONS(1686), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59318] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1192), 2, sym_comment, sym_include, - ACTIONS(1220), 23, + ACTIONS(1688), 25, sym_identifier, + aux_sym__block_terminator_token1, aux_sym_input_expression_token1, aux_sym_variable_definition_token1, aux_sym_variable_definition_token2, @@ -87442,6 +93394,7 @@ static const uint16_t ts_small_parse_table[] = { aux_sym__procedure_terminator_token1, aux_sym_procedure_parameter_definition_token1, aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, aux_sym_class_statement_token1, aux_sym_on_error_phrase_token1, aux_sym_on_error_phrase_token3, @@ -87453,50523 +93406,62043 @@ static const uint16_t ts_small_parse_table[] = { aux_sym_accumulate_statement_token1, anon_sym_ROUTINE_DASHLEVEL, anon_sym_BLOCK_DASHLEVEL, - [56746] = 6, + [59359] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1690), 1, + ts_builtin_sym_end, + STATE(1193), 2, + sym_comment, + sym_include, + ACTIONS(1692), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59402] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1194), 2, + sym_comment, + sym_include, + ACTIONS(1694), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59443] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1350), 1, + ts_builtin_sym_end, + STATE(1195), 2, + sym_comment, + sym_include, + ACTIONS(1352), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59486] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1696), 1, + ts_builtin_sym_end, + STATE(1196), 2, + sym_comment, + sym_include, + ACTIONS(1698), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59529] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1197), 2, + sym_comment, + sym_include, + ACTIONS(1700), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59570] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1702), 1, + ts_builtin_sym_end, + STATE(1198), 2, + sym_comment, + sym_include, + ACTIONS(1664), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59613] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1199), 2, + sym_comment, + sym_include, + ACTIONS(1704), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59654] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1200), 2, + sym_comment, + sym_include, + ACTIONS(1706), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59695] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1708), 1, + ts_builtin_sym_end, + STATE(1201), 2, + sym_comment, + sym_include, + ACTIONS(1710), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59738] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1712), 1, + ts_builtin_sym_end, + STATE(1202), 2, + sym_comment, + sym_include, + ACTIONS(1714), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59781] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1203), 2, + sym_comment, + sym_include, + ACTIONS(1716), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59822] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1204), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59863] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(1205), 2, + sym_comment, + sym_include, + ACTIONS(1356), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59906] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(1206), 2, + sym_comment, + sym_include, + ACTIONS(1356), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59949] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(1207), 2, + sym_comment, + sym_include, + ACTIONS(1356), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [59992] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1354), 1, + ts_builtin_sym_end, + STATE(1208), 2, + sym_comment, + sym_include, + ACTIONS(1356), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60035] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1358), 1, + ts_builtin_sym_end, + STATE(1209), 2, + sym_comment, + sym_include, + ACTIONS(1360), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60078] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1718), 1, + ts_builtin_sym_end, + STATE(1210), 2, + sym_comment, + sym_include, + ACTIONS(1720), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60121] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1362), 1, + ts_builtin_sym_end, + STATE(1211), 2, + sym_comment, + sym_include, + ACTIONS(1364), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60164] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1722), 1, + ts_builtin_sym_end, + STATE(1212), 2, + sym_comment, + sym_include, + ACTIONS(1724), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60207] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1726), 1, + ts_builtin_sym_end, + STATE(1213), 2, + sym_comment, + sym_include, + ACTIONS(1728), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60250] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1214), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60291] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1215), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60332] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1730), 1, + ts_builtin_sym_end, + STATE(1216), 2, + sym_comment, + sym_include, + ACTIONS(1732), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60375] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1734), 1, + ts_builtin_sym_end, + STATE(1217), 2, + sym_comment, + sym_include, + ACTIONS(1736), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60418] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1738), 1, + ts_builtin_sym_end, + STATE(1218), 2, + sym_comment, + sym_include, + ACTIONS(1740), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60461] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1742), 1, + ts_builtin_sym_end, + STATE(1219), 2, + sym_comment, + sym_include, + ACTIONS(1744), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60504] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1746), 1, + ts_builtin_sym_end, + STATE(1220), 2, + sym_comment, + sym_include, + ACTIONS(1748), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60547] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1750), 1, + ts_builtin_sym_end, + STATE(1221), 2, + sym_comment, + sym_include, + ACTIONS(1752), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60590] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1222), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60631] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1754), 1, + ts_builtin_sym_end, + STATE(1223), 2, + sym_comment, + sym_include, + ACTIONS(1756), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60674] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1758), 1, + ts_builtin_sym_end, + STATE(1224), 2, + sym_comment, + sym_include, + ACTIONS(1760), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60717] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1762), 1, + ts_builtin_sym_end, + STATE(1225), 2, + sym_comment, + sym_include, + ACTIONS(1764), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60760] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1226), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60801] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1227), 2, + sym_comment, + sym_include, + ACTIONS(1418), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60842] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1228), 2, + sym_comment, + sym_include, + ACTIONS(1414), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60883] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1229), 2, + sym_comment, + sym_include, + ACTIONS(1766), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60924] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1230), 2, + sym_comment, + sym_include, + ACTIONS(1768), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [60965] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1366), 1, + ts_builtin_sym_end, + STATE(1231), 2, + sym_comment, + sym_include, + ACTIONS(1368), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61008] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1232), 2, + sym_comment, + sym_include, + ACTIONS(1770), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61049] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1772), 1, + ts_builtin_sym_end, + STATE(1233), 2, + sym_comment, + sym_include, + ACTIONS(1774), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61092] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1776), 1, + ts_builtin_sym_end, + STATE(1234), 2, + sym_comment, + sym_include, + ACTIONS(1778), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61135] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1780), 1, + ts_builtin_sym_end, + STATE(1235), 2, + sym_comment, + sym_include, + ACTIONS(1782), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61178] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1784), 1, + ts_builtin_sym_end, + STATE(1236), 2, + sym_comment, + sym_include, + ACTIONS(1786), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61221] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1788), 1, + ts_builtin_sym_end, + STATE(1237), 2, + sym_comment, + sym_include, + ACTIONS(1790), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61264] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1792), 1, + ts_builtin_sym_end, + STATE(1238), 2, + sym_comment, + sym_include, + ACTIONS(1794), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61307] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1239), 2, + sym_comment, + sym_include, + ACTIONS(1796), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61348] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(1240), 2, + sym_comment, + sym_include, + ACTIONS(1438), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61391] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1798), 1, + ts_builtin_sym_end, + STATE(1241), 2, + sym_comment, + sym_include, + ACTIONS(1672), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61434] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1800), 1, + ts_builtin_sym_end, + STATE(1242), 2, + sym_comment, + sym_include, + ACTIONS(1716), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61477] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1464), 1, + ts_builtin_sym_end, + STATE(1243), 2, + sym_comment, + sym_include, + ACTIONS(1466), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61520] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1244), 2, + sym_comment, + sym_include, + ACTIONS(1802), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61561] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(1245), 2, + sym_comment, + sym_include, + ACTIONS(1400), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61604] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(1246), 2, + sym_comment, + sym_include, + ACTIONS(1438), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61647] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(1247), 2, + sym_comment, + sym_include, + ACTIONS(1438), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61690] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1248), 2, + sym_comment, + sym_include, + ACTIONS(1804), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61731] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1249), 2, + sym_comment, + sym_include, + ACTIONS(1806), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61772] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1808), 1, + ts_builtin_sym_end, + STATE(1250), 2, + sym_comment, + sym_include, + ACTIONS(1810), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61815] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1812), 1, + ts_builtin_sym_end, + STATE(1251), 2, + sym_comment, + sym_include, + ACTIONS(1814), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61858] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1252), 2, + sym_comment, + sym_include, + ACTIONS(1410), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61899] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1253), 2, + sym_comment, + sym_include, + ACTIONS(1404), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61940] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1254), 2, + sym_comment, + sym_include, + ACTIONS(1400), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [61981] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1255), 2, + sym_comment, + sym_include, + ACTIONS(1400), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62022] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1256), 2, + sym_comment, + sym_include, + ACTIONS(1400), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62063] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1468), 1, + ts_builtin_sym_end, + STATE(1257), 2, + sym_comment, + sym_include, + ACTIONS(1470), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62106] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1432), 1, + ts_builtin_sym_end, + STATE(1258), 2, + sym_comment, + sym_include, + ACTIONS(1434), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62149] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1259), 2, + sym_comment, + sym_include, + ACTIONS(1400), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62190] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1260), 2, + sym_comment, + sym_include, + ACTIONS(1466), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62231] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1816), 1, + ts_builtin_sym_end, + STATE(1261), 2, + sym_comment, + sym_include, + ACTIONS(1602), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62274] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1818), 1, + ts_builtin_sym_end, + STATE(1262), 2, + sym_comment, + sym_include, + ACTIONS(1820), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62317] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1263), 2, + sym_comment, + sym_include, + ACTIONS(1810), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62358] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1822), 1, + ts_builtin_sym_end, + STATE(1264), 2, + sym_comment, + sym_include, + ACTIONS(1608), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62401] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1824), 1, + ts_builtin_sym_end, + STATE(1265), 2, + sym_comment, + sym_include, + ACTIONS(1610), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62444] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1266), 2, + sym_comment, + sym_include, + ACTIONS(1396), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62485] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1267), 2, + sym_comment, + sym_include, + ACTIONS(1826), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62526] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1828), 1, + ts_builtin_sym_end, + STATE(1268), 2, + sym_comment, + sym_include, + ACTIONS(1618), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62569] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1269), 2, + sym_comment, + sym_include, + ACTIONS(1830), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62610] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1270), 2, + sym_comment, + sym_include, + ACTIONS(1832), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62651] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1271), 2, + sym_comment, + sym_include, + ACTIONS(1834), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62692] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1836), 1, + ts_builtin_sym_end, + STATE(1272), 2, + sym_comment, + sym_include, + ACTIONS(1620), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62735] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1838), 1, + ts_builtin_sym_end, + STATE(1273), 2, + sym_comment, + sym_include, + ACTIONS(1628), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62778] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1274), 2, + sym_comment, + sym_include, + ACTIONS(1840), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62819] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1275), 2, + sym_comment, + sym_include, + ACTIONS(1842), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62860] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1276), 2, + sym_comment, + sym_include, + ACTIONS(1844), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62901] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1277), 2, + sym_comment, + sym_include, + ACTIONS(1846), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62942] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1278), 2, + sym_comment, + sym_include, + ACTIONS(1848), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [62983] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1279), 2, + sym_comment, + sym_include, + ACTIONS(1850), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63024] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(1280), 2, + sym_comment, + sym_include, + ACTIONS(1390), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63067] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1281), 2, + sym_comment, + sym_include, + ACTIONS(1814), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63108] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1282), 2, + sym_comment, + sym_include, + ACTIONS(1470), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63149] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(1283), 2, + sym_comment, + sym_include, + ACTIONS(1390), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63192] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1284), 2, + sym_comment, + sym_include, + ACTIONS(1820), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63233] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1285), 2, + sym_comment, + sym_include, + ACTIONS(1852), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63274] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1286), 2, + sym_comment, + sym_include, + ACTIONS(1390), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63315] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1287), 2, + sym_comment, + sym_include, + ACTIONS(1390), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63356] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1288), 2, + sym_comment, + sym_include, + ACTIONS(1390), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63397] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1289), 2, + sym_comment, + sym_include, + ACTIONS(1390), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63438] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1290), 2, + sym_comment, + sym_include, + ACTIONS(1386), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63479] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1291), 2, + sym_comment, + sym_include, + ACTIONS(1854), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63520] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1292), 2, + sym_comment, + sym_include, + ACTIONS(1856), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63561] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1472), 1, + ts_builtin_sym_end, + STATE(1293), 2, + sym_comment, + sym_include, + ACTIONS(1474), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63604] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1294), 2, + sym_comment, + sym_include, + ACTIONS(1858), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63645] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1398), 1, + ts_builtin_sym_end, + STATE(1295), 2, + sym_comment, + sym_include, + ACTIONS(1400), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63688] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1296), 2, + sym_comment, + sym_include, + ACTIONS(1860), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63729] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1297), 2, + sym_comment, + sym_include, + ACTIONS(1862), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63770] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1864), 1, + ts_builtin_sym_end, + STATE(1298), 2, + sym_comment, + sym_include, + ACTIONS(1644), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63813] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1866), 1, + ts_builtin_sym_end, + STATE(1299), 2, + sym_comment, + sym_include, + ACTIONS(1868), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63856] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1870), 1, + ts_builtin_sym_end, + STATE(1300), 2, + sym_comment, + sym_include, + ACTIONS(1872), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63899] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1874), 1, + ts_builtin_sym_end, + STATE(1301), 2, + sym_comment, + sym_include, + ACTIONS(1654), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63942] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1302), 2, + sym_comment, + sym_include, + ACTIONS(1876), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [63983] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1476), 1, + ts_builtin_sym_end, + STATE(1303), 2, + sym_comment, + sym_include, + ACTIONS(1478), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64026] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1304), 2, + sym_comment, + sym_include, + ACTIONS(1878), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64067] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1305), 2, + sym_comment, + sym_include, + ACTIONS(1880), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64108] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1428), 1, + ts_builtin_sym_end, + STATE(1306), 2, + sym_comment, + sym_include, + ACTIONS(1430), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64151] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1424), 1, + ts_builtin_sym_end, + STATE(1307), 2, + sym_comment, + sym_include, + ACTIONS(1426), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64194] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1308), 2, + sym_comment, + sym_include, + ACTIONS(1882), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64235] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1309), 2, + sym_comment, + sym_include, + ACTIONS(1884), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64276] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1310), 2, + sym_comment, + sym_include, + ACTIONS(1886), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64317] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1311), 2, + sym_comment, + sym_include, + ACTIONS(1888), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64358] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1312), 2, + sym_comment, + sym_include, + ACTIONS(1382), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64399] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1313), 2, + sym_comment, + sym_include, + ACTIONS(1378), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64440] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1314), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64481] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1315), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64522] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1316), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64563] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1317), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64604] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1507), 1, + sym_of, + STATE(1546), 1, + sym__pre_tuning, + STATE(1623), 1, + aux_sym_for_phrase_repeat1, + STATE(1633), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1904), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2291), 1, + sym_on_error_phrase, + STATE(2410), 1, + sym_on_quit_phrase, + STATE(3271), 1, + sym_on_stop_phrase, + ACTIONS(1890), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1318), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [64683] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1319), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64724] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1370), 1, + ts_builtin_sym_end, + STATE(1320), 2, + sym_comment, + sym_include, + ACTIONS(1372), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64767] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1321), 2, + sym_comment, + sym_include, + ACTIONS(1276), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64808] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1322), 2, + sym_comment, + sym_include, + ACTIONS(1474), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64849] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1323), 2, + sym_comment, + sym_include, + ACTIONS(1868), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64890] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1388), 1, + ts_builtin_sym_end, + STATE(1324), 2, + sym_comment, + sym_include, + ACTIONS(1390), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64933] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1420), 1, + ts_builtin_sym_end, + STATE(1325), 2, + sym_comment, + sym_include, + ACTIONS(1422), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [64976] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1326), 2, + sym_comment, + sym_include, + ACTIONS(1892), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65017] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1894), 1, + ts_builtin_sym_end, + STATE(1327), 2, + sym_comment, + sym_include, + ACTIONS(1892), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65060] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1480), 1, + ts_builtin_sym_end, + STATE(1328), 2, + sym_comment, + sym_include, + ACTIONS(1482), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65103] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1329), 2, + sym_comment, + sym_include, + ACTIONS(1478), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65144] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1330), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65187] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1331), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65230] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1332), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65273] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1333), 2, + sym_comment, + sym_include, + ACTIONS(1482), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65314] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1334), 2, + sym_comment, + sym_include, + ACTIONS(1486), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65355] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1484), 1, + ts_builtin_sym_end, + STATE(1335), 2, + sym_comment, + sym_include, + ACTIONS(1486), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65398] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1336), 2, + sym_comment, + sym_include, + ACTIONS(1372), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65439] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1337), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65482] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1338), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65525] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1374), 1, + ts_builtin_sym_end, + STATE(1339), 2, + sym_comment, + sym_include, + ACTIONS(1276), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65568] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1376), 1, + ts_builtin_sym_end, + STATE(1340), 2, + sym_comment, + sym_include, + ACTIONS(1378), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65611] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1380), 1, + ts_builtin_sym_end, + STATE(1341), 2, + sym_comment, + sym_include, + ACTIONS(1382), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65654] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1896), 1, + ts_builtin_sym_end, + STATE(1342), 2, + sym_comment, + sym_include, + ACTIONS(1888), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65697] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1343), 2, + sym_comment, + sym_include, + ACTIONS(1872), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65738] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1898), 1, + ts_builtin_sym_end, + STATE(1344), 2, + sym_comment, + sym_include, + ACTIONS(1886), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65781] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1345), 2, + sym_comment, + sym_include, + ACTIONS(1794), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65822] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1900), 1, + ts_builtin_sym_end, + STATE(1346), 2, + sym_comment, + sym_include, + ACTIONS(1684), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65865] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1347), 2, + sym_comment, + sym_include, + ACTIONS(1790), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65906] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1348), 2, + sym_comment, + sym_include, + ACTIONS(1786), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65947] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1902), 1, + ts_builtin_sym_end, + STATE(1349), 2, + sym_comment, + sym_include, + ACTIONS(1686), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [65990] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1904), 1, + ts_builtin_sym_end, + STATE(1350), 2, + sym_comment, + sym_include, + ACTIONS(1688), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66033] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1906), 1, + ts_builtin_sym_end, + STATE(1351), 2, + sym_comment, + sym_include, + ACTIONS(1694), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66076] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1488), 1, + ts_builtin_sym_end, + STATE(1352), 2, + sym_comment, + sym_include, + ACTIONS(1490), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66119] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1353), 2, + sym_comment, + sym_include, + ACTIONS(1782), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66160] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1354), 2, + sym_comment, + sym_include, + ACTIONS(1778), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66201] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1908), 1, + ts_builtin_sym_end, + STATE(1355), 2, + sym_comment, + sym_include, + ACTIONS(1700), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66244] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1910), 1, + ts_builtin_sym_end, + STATE(1356), 2, + sym_comment, + sym_include, + ACTIONS(1852), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66287] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1492), 1, + ts_builtin_sym_end, + STATE(1357), 2, + sym_comment, + sym_include, + ACTIONS(1494), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66330] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1358), 2, + sym_comment, + sym_include, + ACTIONS(1490), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66371] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1359), 2, + sym_comment, + sym_include, + ACTIONS(1494), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66412] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1912), 1, + ts_builtin_sym_end, + STATE(1360), 2, + sym_comment, + sym_include, + ACTIONS(1704), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66455] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1361), 2, + sym_comment, + sym_include, + ACTIONS(1500), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66496] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1362), 2, + sym_comment, + sym_include, + ACTIONS(1504), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66537] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1363), 2, + sym_comment, + sym_include, + ACTIONS(1774), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66578] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1364), 2, + sym_comment, + sym_include, + ACTIONS(1368), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66619] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1365), 2, + sym_comment, + sym_include, + ACTIONS(1764), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66660] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1914), 1, + ts_builtin_sym_end, + STATE(1366), 2, + sym_comment, + sym_include, + ACTIONS(1706), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66703] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1367), 2, + sym_comment, + sym_include, + ACTIONS(1760), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66744] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1368), 2, + sym_comment, + sym_include, + ACTIONS(1756), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66785] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1369), 2, + sym_comment, + sym_include, + ACTIONS(1752), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66826] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1498), 1, + ts_builtin_sym_end, + STATE(1370), 2, + sym_comment, + sym_include, + ACTIONS(1500), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66869] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(1371), 2, + sym_comment, + sym_include, + ACTIONS(1418), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66912] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1372), 2, + sym_comment, + sym_include, + ACTIONS(1748), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66953] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1502), 1, + ts_builtin_sym_end, + STATE(1373), 2, + sym_comment, + sym_include, + ACTIONS(1504), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [66996] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(1374), 2, + sym_comment, + sym_include, + ACTIONS(1418), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67039] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(1375), 2, + sym_comment, + sym_include, + ACTIONS(1418), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67082] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(1376), 2, + sym_comment, + sym_include, + ACTIONS(1418), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67125] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1377), 2, + sym_comment, + sym_include, + ACTIONS(1744), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67166] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1436), 1, + ts_builtin_sym_end, + STATE(1378), 2, + sym_comment, + sym_include, + ACTIONS(1438), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67209] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1379), 2, + sym_comment, + sym_include, + ACTIONS(1740), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67250] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1416), 1, + ts_builtin_sym_end, + STATE(1380), 2, + sym_comment, + sym_include, + ACTIONS(1418), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67293] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1506), 1, + ts_builtin_sym_end, + STATE(1381), 2, + sym_comment, + sym_include, + ACTIONS(1508), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67336] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1382), 2, + sym_comment, + sym_include, + ACTIONS(1736), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67377] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1383), 2, + sym_comment, + sym_include, + ACTIONS(1732), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67418] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1384), 2, + sym_comment, + sym_include, + ACTIONS(1728), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67459] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1510), 1, + ts_builtin_sym_end, + STATE(1385), 2, + sym_comment, + sym_include, + ACTIONS(1512), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67502] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1386), 2, + sym_comment, + sym_include, + ACTIONS(1724), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67543] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1387), 2, + sym_comment, + sym_include, + ACTIONS(1916), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67584] = 8, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1918), 1, + aux_sym_buffer_definition_token2, + ACTIONS(1920), 1, + aux_sym_repeat_statement_token1, + ACTIONS(1922), 1, + aux_sym_do_while_statement_token1, + STATE(1388), 2, + sym_comment, + sym_include, + ACTIONS(1916), 22, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67631] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1389), 2, + sym_comment, + sym_include, + ACTIONS(1924), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67672] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1390), 2, + sym_comment, + sym_include, + ACTIONS(1926), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67713] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1391), 2, + sym_comment, + sym_include, + ACTIONS(1928), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67754] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1392), 2, + sym_comment, + sym_include, + ACTIONS(1508), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67795] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1393), 2, + sym_comment, + sym_include, + ACTIONS(1298), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67836] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1394), 2, + sym_comment, + sym_include, + ACTIONS(1364), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67877] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1395), 2, + sym_comment, + sym_include, + ACTIONS(1720), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67918] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1412), 1, + ts_builtin_sym_end, + STATE(1396), 2, + sym_comment, + sym_include, + ACTIONS(1414), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [67961] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1930), 1, + ts_builtin_sym_end, + STATE(1397), 2, + sym_comment, + sym_include, + ACTIONS(1766), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68004] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1398), 2, + sym_comment, + sym_include, + ACTIONS(1360), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68045] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1399), 2, + sym_comment, + sym_include, + ACTIONS(1356), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68086] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1400), 2, + sym_comment, + sym_include, + ACTIONS(1356), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68127] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1401), 2, + sym_comment, + sym_include, + ACTIONS(1356), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68168] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1402), 2, + sym_comment, + sym_include, + ACTIONS(1932), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68209] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1934), 1, + ts_builtin_sym_end, + STATE(1403), 2, + sym_comment, + sym_include, + ACTIONS(1768), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68252] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1404), 2, + sym_comment, + sym_include, + ACTIONS(1356), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68293] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1936), 1, + ts_builtin_sym_end, + STATE(1405), 2, + sym_comment, + sym_include, + ACTIONS(1770), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68336] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1406), 2, + sym_comment, + sym_include, + ACTIONS(1512), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68377] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1407), 2, + sym_comment, + sym_include, + ACTIONS(1302), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68418] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1408), 2, + sym_comment, + sym_include, + ACTIONS(1544), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68459] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1409), 2, + sym_comment, + sym_include, + ACTIONS(1306), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68500] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1410), 2, + sym_comment, + sym_include, + ACTIONS(1310), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68541] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1938), 1, + ts_builtin_sym_end, + STATE(1411), 2, + sym_comment, + sym_include, + ACTIONS(1796), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68584] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1940), 1, + ts_builtin_sym_end, + STATE(1412), 2, + sym_comment, + sym_include, + ACTIONS(1916), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68627] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1413), 2, + sym_comment, + sym_include, + ACTIONS(1714), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68668] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1394), 1, + ts_builtin_sym_end, + STATE(1414), 2, + sym_comment, + sym_include, + ACTIONS(1396), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68711] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1415), 2, + sym_comment, + sym_include, + ACTIONS(1710), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68752] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1940), 1, + ts_builtin_sym_end, + ACTIONS(1942), 1, + aux_sym_buffer_definition_token2, + ACTIONS(1944), 1, + aux_sym_repeat_statement_token1, + ACTIONS(1946), 1, + aux_sym_do_while_statement_token1, + STATE(1416), 2, + sym_comment, + sym_include, + ACTIONS(1916), 21, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68801] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1384), 1, + ts_builtin_sym_end, + STATE(1417), 2, + sym_comment, + sym_include, + ACTIONS(1386), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68844] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1418), 2, + sym_comment, + sym_include, + ACTIONS(1352), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68885] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1419), 2, + sym_comment, + sym_include, + ACTIONS(1692), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68926] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1420), 2, + sym_comment, + sym_include, + ACTIONS(1682), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [68967] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1948), 1, + ts_builtin_sym_end, + STATE(1421), 2, + sym_comment, + sym_include, + ACTIONS(1802), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69010] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1422), 2, + sym_comment, + sym_include, + ACTIONS(1678), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69051] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1950), 1, + ts_builtin_sym_end, + STATE(1423), 2, + sym_comment, + sym_include, + ACTIONS(1884), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69094] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1952), 1, + ts_builtin_sym_end, + STATE(1424), 2, + sym_comment, + sym_include, + ACTIONS(1850), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69137] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1954), 1, + ts_builtin_sym_end, + STATE(1425), 2, + sym_comment, + sym_include, + ACTIONS(1924), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69180] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1956), 1, + ts_builtin_sym_end, + STATE(1426), 2, + sym_comment, + sym_include, + ACTIONS(1826), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69223] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1958), 1, + ts_builtin_sym_end, + STATE(1427), 2, + sym_comment, + sym_include, + ACTIONS(1848), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69266] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1960), 1, + ts_builtin_sym_end, + STATE(1428), 2, + sym_comment, + sym_include, + ACTIONS(1926), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69309] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1962), 1, + ts_builtin_sym_end, + STATE(1429), 2, + sym_comment, + sym_include, + ACTIONS(1804), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69352] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1964), 1, + ts_builtin_sym_end, + STATE(1430), 2, + sym_comment, + sym_include, + ACTIONS(1830), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69395] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1966), 1, + ts_builtin_sym_end, + STATE(1431), 2, + sym_comment, + sym_include, + ACTIONS(1846), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69438] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1968), 1, + ts_builtin_sym_end, + STATE(1432), 2, + sym_comment, + sym_include, + ACTIONS(1806), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69481] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1433), 2, + sym_comment, + sym_include, + ACTIONS(1668), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69522] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1434), 2, + sym_comment, + sym_include, + ACTIONS(1320), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69563] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1435), 2, + sym_comment, + sym_include, + ACTIONS(1568), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69604] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1436), 2, + sym_comment, + sym_include, + ACTIONS(1574), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69645] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1437), 2, + sym_comment, + sym_include, + ACTIONS(1324), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69686] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1438), 2, + sym_comment, + sym_include, + ACTIONS(1328), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69727] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1439), 2, + sym_comment, + sym_include, + ACTIONS(1332), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69768] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1440), 2, + sym_comment, + sym_include, + ACTIONS(1580), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69809] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1441), 2, + sym_comment, + sym_include, + ACTIONS(1584), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69850] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1442), 2, + sym_comment, + sym_include, + ACTIONS(1588), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69891] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1970), 1, + ts_builtin_sym_end, + STATE(1443), 2, + sym_comment, + sym_include, + ACTIONS(1832), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69934] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1444), 2, + sym_comment, + sym_include, + ACTIONS(1662), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [69975] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1972), 1, + ts_builtin_sym_end, + STATE(1445), 2, + sym_comment, + sym_include, + ACTIONS(1834), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70018] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1446), 2, + sym_comment, + sym_include, + ACTIONS(1658), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70059] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1974), 1, + ts_builtin_sym_end, + STATE(1447), 2, + sym_comment, + sym_include, + ACTIONS(1840), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70102] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1448), 2, + sym_comment, + sym_include, + ACTIONS(1652), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70143] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1449), 2, + sym_comment, + sym_include, + ACTIONS(1640), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70184] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1976), 1, + ts_builtin_sym_end, + STATE(1450), 2, + sym_comment, + sym_include, + ACTIONS(1882), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70227] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1978), 1, + ts_builtin_sym_end, + STATE(1451), 2, + sym_comment, + sym_include, + ACTIONS(1880), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70270] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1452), 2, + sym_comment, + sym_include, + ACTIONS(1636), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70311] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1980), 1, + ts_builtin_sym_end, + STATE(1453), 2, + sym_comment, + sym_include, + ACTIONS(1854), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70354] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1454), 2, + sym_comment, + sym_include, + ACTIONS(1632), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70395] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1982), 1, + ts_builtin_sym_end, + STATE(1455), 2, + sym_comment, + sym_include, + ACTIONS(1856), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70438] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1984), 1, + ts_builtin_sym_end, + STATE(1456), 2, + sym_comment, + sym_include, + ACTIONS(1878), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70481] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1986), 1, + ts_builtin_sym_end, + STATE(1457), 2, + sym_comment, + sym_include, + ACTIONS(1876), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70524] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1988), 1, + ts_builtin_sym_end, + STATE(1458), 2, + sym_comment, + sym_include, + ACTIONS(1862), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70567] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1459), 2, + sym_comment, + sym_include, + ACTIONS(1592), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70608] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1460), 2, + sym_comment, + sym_include, + ACTIONS(1596), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70649] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1461), 2, + sym_comment, + sym_include, + ACTIONS(1600), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70690] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1462), 2, + sym_comment, + sym_include, + ACTIONS(1606), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70731] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1990), 1, + ts_builtin_sym_end, + STATE(1463), 2, + sym_comment, + sym_include, + ACTIONS(1932), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70774] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1296), 1, + ts_builtin_sym_end, + STATE(1464), 2, + sym_comment, + sym_include, + ACTIONS(1298), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70817] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1992), 1, + ts_builtin_sym_end, + STATE(1465), 2, + sym_comment, + sym_include, + ACTIONS(1842), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70860] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1994), 1, + ts_builtin_sym_end, + STATE(1466), 2, + sym_comment, + sym_include, + ACTIONS(1928), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70903] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1467), 2, + sym_comment, + sym_include, + ACTIONS(1336), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70944] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1468), 2, + sym_comment, + sym_include, + ACTIONS(1340), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [70985] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1469), 2, + sym_comment, + sym_include, + ACTIONS(1344), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71026] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1470), 2, + sym_comment, + sym_include, + ACTIONS(1348), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71067] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1471), 2, + sym_comment, + sym_include, + ACTIONS(1614), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71108] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1996), 1, + ts_builtin_sym_end, + STATE(1472), 2, + sym_comment, + sym_include, + ACTIONS(1844), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71151] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(1998), 1, + ts_builtin_sym_end, + STATE(1473), 2, + sym_comment, + sym_include, + ACTIONS(1860), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71194] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(1474), 2, + sym_comment, + sym_include, + ACTIONS(1698), 25, + sym_identifier, + aux_sym__block_terminator_token1, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71235] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(2000), 1, + ts_builtin_sym_end, + STATE(1475), 2, + sym_comment, + sym_include, + ACTIONS(1858), 24, + sym_identifier, + aux_sym_input_expression_token1, + aux_sym_variable_definition_token1, + aux_sym_variable_definition_token2, + aux_sym_buffer_definition_token2, + aux_sym_argument_mode_token1, + aux_sym_if_statement_token1, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + aux_sym__procedure_terminator_token1, + aux_sym_procedure_parameter_definition_token1, + aux_sym__function_terminator_token1, + aux_sym_interface_statement_token1, + aux_sym_class_statement_token1, + aux_sym_on_error_phrase_token1, + aux_sym_on_error_phrase_token3, + aux_sym__case_terminator_token1, + aux_sym_find_statement_token1, + aux_sym_assign_statement_token1, + aux_sym_catch_statement_token1, + aux_sym_finally_statement_token1, + aux_sym_accumulate_statement_token1, + anon_sym_ROUTINE_DASHLEVEL, + anon_sym_BLOCK_DASHLEVEL, + [71278] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1530), 1, + anon_sym_COLON, + STATE(1489), 1, + sym_of, + STATE(1535), 1, + sym__pre_tuning, + STATE(1591), 1, + aux_sym_for_phrase_repeat1, + STATE(1594), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1867), 1, + aux_sym_for_phrase_repeat2, + STATE(2216), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2299), 1, + sym_on_quit_phrase, + STATE(2860), 1, + aux_sym_for_statement_repeat1, + STATE(2868), 1, + sym_on_stop_phrase, + STATE(1476), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71356] = 19, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2002), 1, + aux_sym_input_expression_token1, + ACTIONS(2010), 1, + aux_sym_variable_definition_token3, + ACTIONS(2012), 1, + aux_sym_variable_definition_token4, + ACTIONS(2014), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2016), 1, + aux_sym_buffer_definition_token3, + ACTIONS(2018), 1, + aux_sym_query_definition_token1, + ACTIONS(2022), 1, + aux_sym_stream_definition_token1, + STATE(1645), 1, + aux_sym_variable_definition_repeat1, + STATE(1788), 1, + aux_sym_buffer_definition_repeat1, + STATE(1792), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1477), 2, + sym_comment, + sym_include, + STATE(1711), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2020), 3, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [71424] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1514), 1, + anon_sym_COLON, + STATE(1499), 1, + sym_of, + STATE(1540), 1, + sym__pre_tuning, + STATE(1588), 1, + sym_where_clause, + STATE(1589), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1884), 1, + aux_sym_for_phrase_repeat2, + STATE(2141), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2317), 1, + sym_on_quit_phrase, + STATE(2706), 1, + aux_sym_for_statement_repeat1, + STATE(2707), 1, + sym_on_stop_phrase, + STATE(1478), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71502] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1406), 1, + anon_sym_COLON, + STATE(1498), 1, + sym_of, + STATE(1519), 1, + sym__pre_tuning, + STATE(1576), 1, + sym_where_clause, + STATE(1606), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1839), 1, + aux_sym_for_phrase_repeat2, + STATE(2133), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2268), 1, + sym_on_quit_phrase, + STATE(2623), 1, + aux_sym_for_statement_repeat1, + STATE(2626), 1, + sym_on_stop_phrase, + STATE(1479), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71580] = 19, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2024), 1, + aux_sym_input_expression_token1, + ACTIONS(2026), 1, + aux_sym_variable_definition_token3, + ACTIONS(2028), 1, + aux_sym_variable_definition_token4, + ACTIONS(2030), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2032), 1, + aux_sym_buffer_definition_token3, + ACTIONS(2034), 1, + aux_sym_query_definition_token1, + ACTIONS(2038), 1, + aux_sym_stream_definition_token1, + STATE(1650), 1, + aux_sym_variable_definition_repeat1, + STATE(1770), 1, + aux_sym_buffer_definition_repeat1, + STATE(1792), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1480), 2, + sym_comment, + sym_include, + STATE(1711), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2036), 3, + aux_sym_argument_mode_token1, + aux_sym_argument_mode_token2, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [71648] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1392), 1, + anon_sym_COLON, + STATE(1493), 1, + sym_of, + STATE(1510), 1, + sym__pre_tuning, + STATE(1558), 1, + sym_where_clause, + STATE(1582), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1882), 1, + aux_sym_for_phrase_repeat2, + STATE(2145), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2260), 1, + sym_on_quit_phrase, + STATE(2614), 1, + aux_sym_for_statement_repeat1, + STATE(2617), 1, + sym_on_stop_phrase, + STATE(1481), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71726] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1526), 1, + anon_sym_COLON, + STATE(1496), 1, + sym_of, + STATE(1517), 1, + sym__pre_tuning, + STATE(1602), 1, + sym_where_clause, + STATE(1608), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1799), 1, + aux_sym_for_phrase_repeat2, + STATE(2146), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2228), 1, + sym_on_quit_phrase, + STATE(2570), 1, + aux_sym_for_statement_repeat1, + STATE(2583), 1, + sym_on_stop_phrase, + STATE(1482), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71804] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1518), 1, + anon_sym_COLON, + STATE(1502), 1, + sym_of, + STATE(1520), 1, + sym__pre_tuning, + STATE(1562), 1, + aux_sym_for_phrase_repeat1, + STATE(1563), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1827), 1, + aux_sym_for_phrase_repeat2, + STATE(2167), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2354), 1, + sym_on_quit_phrase, + STATE(2762), 1, + aux_sym_for_statement_repeat1, + STATE(2766), 1, + sym_on_stop_phrase, + STATE(1483), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71882] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1520), 1, + anon_sym_COLON, + STATE(1494), 1, + sym_of, + STATE(1543), 1, + sym__pre_tuning, + STATE(1566), 1, + aux_sym_for_phrase_repeat1, + STATE(1568), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1837), 1, + aux_sym_for_phrase_repeat2, + STATE(2176), 1, + sym_on_error_phrase, + STATE(2223), 1, + sym_on_quit_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2776), 1, + aux_sym_for_statement_repeat1, + STATE(2778), 1, + sym_on_stop_phrase, + STATE(1484), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [71960] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1280), 1, + anon_sym_COLON, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1490), 1, + sym_of, + STATE(1529), 1, + sym__pre_tuning, + STATE(1601), 1, + aux_sym_for_phrase_repeat1, + STATE(1605), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1849), 1, + aux_sym_for_phrase_repeat2, + STATE(2209), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2230), 1, + sym_on_quit_phrase, + STATE(2646), 1, + sym_on_stop_phrase, + STATE(2677), 1, + aux_sym_for_statement_repeat1, + STATE(1485), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72038] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1522), 1, + anon_sym_COLON, + STATE(1491), 1, + sym_of, + STATE(1542), 1, + sym__pre_tuning, + STATE(1581), 1, + aux_sym_for_phrase_repeat1, + STATE(1584), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1879), 1, + aux_sym_for_phrase_repeat2, + STATE(2204), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2305), 1, + sym_on_quit_phrase, + STATE(2843), 1, + aux_sym_for_statement_repeat1, + STATE(2845), 1, + sym_on_stop_phrase, + STATE(1486), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72116] = 24, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(1496), 1, + anon_sym_COLON, + STATE(1497), 1, + sym_of, + STATE(1534), 1, + sym__pre_tuning, + STATE(1595), 1, + sym_where_clause, + STATE(1599), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1820), 1, + aux_sym_for_phrase_repeat2, + STATE(2132), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2304), 1, + sym_on_quit_phrase, + STATE(2682), 1, + aux_sym_for_statement_repeat1, + STATE(2686), 1, + sym_on_stop_phrase, + STATE(1487), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72194] = 22, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1507), 1, + sym_of, + STATE(1546), 1, + sym__pre_tuning, + STATE(1623), 1, + aux_sym_for_phrase_repeat1, + STATE(1633), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1904), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2291), 1, + sym_on_error_phrase, + STATE(2410), 1, + sym_on_quit_phrase, + STATE(3271), 1, + sym_on_stop_phrase, + ACTIONS(1890), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1488), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72267] = 22, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2040), 1, + anon_sym_COLON, + STATE(1541), 1, + sym__pre_tuning, + STATE(1586), 1, + sym_where_clause, + STATE(1587), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1874), 1, + aux_sym_for_phrase_repeat2, + STATE(2207), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2303), 1, + sym_on_quit_phrase, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, + sym_on_stop_phrase, + STATE(1489), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72339] = 22, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2042), 1, + anon_sym_COLON, + STATE(1533), 1, + sym__pre_tuning, + STATE(1567), 1, + sym_where_clause, + STATE(1583), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1832), 1, + aux_sym_for_phrase_repeat2, + STATE(2199), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2242), 1, + sym_on_quit_phrase, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(1490), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72411] = 22, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(1150), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2044), 1, + anon_sym_COLON, + STATE(1537), 1, + sym__pre_tuning, + STATE(1577), 1, + sym_where_clause, + STATE(1578), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1866), 1, + aux_sym_for_phrase_repeat2, + STATE(2195), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2310), 1, + sym_on_quit_phrase, + STATE(2833), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(1491), 2, sym_comment, sym_include, - ACTIONS(1220), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56788] = 6, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72483] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(1151), 2, + STATE(1492), 2, sym_comment, sym_include, - ACTIONS(1220), 23, + ACTIONS(2046), 23, + anon_sym_LBRACE, sym_identifier, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56830] = 6, - ACTIONS(3), 1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [72519] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1218), 1, - ts_builtin_sym_end, - STATE(1152), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(1523), 1, + sym__pre_tuning, + STATE(1603), 1, + aux_sym_for_phrase_repeat1, + STATE(1609), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1873), 1, + aux_sym_for_phrase_repeat2, + STATE(2173), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2254), 1, + sym_on_quit_phrase, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 1, + sym_on_stop_phrase, + STATE(1493), 2, sym_comment, sym_include, - ACTIONS(1220), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56872] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72591] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1792), 1, - ts_builtin_sym_end, - STATE(1153), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2050), 1, + anon_sym_COLON, + STATE(1536), 1, + sym__pre_tuning, + STATE(1564), 1, + sym_where_clause, + STATE(1565), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1833), 1, + aux_sym_for_phrase_repeat2, + STATE(2171), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(1494), 2, sym_comment, sym_include, - ACTIONS(1794), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56914] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72663] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1796), 1, - ts_builtin_sym_end, - STATE(1154), 2, + ACTIONS(2054), 1, + aux_sym_variable_definition_token2, + STATE(1495), 2, sym_comment, sym_include, - ACTIONS(1798), 23, - sym_identifier, - aux_sym_input_expression_token1, + ACTIONS(2052), 21, + sym__terminator, + aux_sym__block_terminator_token1, + anon_sym_LPAREN, + anon_sym_RPAREN, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56956] = 6, - ACTIONS(3), 1, + anon_sym_COMMA, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_property_definition_token2, + aux_sym_method_definition_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [72703] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1800), 1, - ts_builtin_sym_end, - STATE(1155), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2056), 1, + anon_sym_COLON, + STATE(1528), 1, + sym__pre_tuning, + STATE(1549), 1, + aux_sym_for_phrase_repeat1, + STATE(1612), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1880), 1, + aux_sym_for_phrase_repeat2, + STATE(2183), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2278), 1, + sym_on_quit_phrase, + STATE(2636), 1, + sym_on_stop_phrase, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(1496), 2, sym_comment, sym_include, - ACTIONS(1802), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [56998] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72775] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1804), 1, - ts_builtin_sym_end, - STATE(1156), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(1527), 1, + sym__pre_tuning, + STATE(1611), 1, + aux_sym_for_phrase_repeat1, + STATE(1613), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1868), 1, + aux_sym_for_phrase_repeat2, + STATE(2124), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2295), 1, + sym_on_quit_phrase, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(1497), 2, sym_comment, sym_include, - ACTIONS(1806), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57040] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72847] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1808), 1, - ts_builtin_sym_end, - STATE(1157), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(1512), 1, + sym__pre_tuning, + STATE(1585), 1, + sym_where_clause, + STATE(1600), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1859), 1, + aux_sym_for_phrase_repeat2, + STATE(2139), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2263), 1, + sym_on_quit_phrase, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(1498), 2, sym_comment, sym_include, - ACTIONS(1810), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72919] = 22, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57082] = 5, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(1506), 1, + sym__pre_tuning, + STATE(1590), 1, + aux_sym_for_phrase_repeat1, + STATE(1593), 1, + sym_where_clause, + STATE(1720), 1, + sym_query_tuning, + STATE(1852), 1, + aux_sym_for_phrase_repeat2, + STATE(2135), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2308), 1, + sym_on_quit_phrase, + STATE(2691), 1, + aux_sym_for_statement_repeat1, + STATE(2693), 1, + sym_on_stop_phrase, + STATE(1499), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [72991] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(1158), 2, + STATE(1500), 2, sym_comment, sym_include, - ACTIONS(1394), 24, + ACTIONS(2064), 23, + anon_sym_LBRACE, sym_identifier, - aux_sym__block_terminator_token1, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57122] = 5, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [73027] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(1159), 2, + STATE(1501), 2, sym_comment, sym_include, - ACTIONS(1812), 24, + ACTIONS(2066), 23, + anon_sym_LBRACE, sym_identifier, - aux_sym__block_terminator_token1, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57162] = 5, - ACTIONS(3), 1, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [73063] = 22, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1160), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(1544), 1, + sym__pre_tuning, + STATE(1557), 1, + sym_where_clause, + STATE(1559), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1819), 1, + aux_sym_for_phrase_repeat2, + STATE(2163), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(1502), 2, sym_comment, sym_include, - ACTIONS(1388), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57202] = 5, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [73135] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - STATE(1161), 2, + STATE(1503), 2, sym_comment, sym_include, - ACTIONS(1384), 24, + ACTIONS(2070), 23, + anon_sym_LBRACE, sym_identifier, - aux_sym__block_terminator_token1, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57242] = 6, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [73171] = 4, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1814), 1, - ts_builtin_sym_end, - STATE(1162), 2, + STATE(1504), 2, sym_comment, sym_include, - ACTIONS(1816), 23, + ACTIONS(2072), 23, + anon_sym_LBRACE, sym_identifier, + sym_null_expression, + aux_sym_boolean_literal_token1, + aux_sym_boolean_literal_token2, + aux_sym_boolean_literal_token3, + aux_sym_boolean_literal_token4, + sym__integer_literal, + anon_sym_DQUOTE, + anon_sym_SQUOTE, + anon_sym_LPAREN, + aux_sym_unary_expression_token1, + aux_sym_unary_expression_token2, + aux_sym_ambiguous_expression_token1, + aux_sym_current_changed_expression_token1, + aux_sym_locked_expression_token1, aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + aux_sym_scope_tuning_token1, aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57284] = 6, + aux_sym_can_find_expression_token1, + aux_sym_accumulate_expression_token1, + aux_sym_available_expression_token1, + aux_sym_available_expression_token2, + [73207] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1818), 1, - ts_builtin_sym_end, - STATE(1163), 2, + ACTIONS(1622), 1, + sym_identifier, + STATE(3575), 1, + sym_primitive_type, + STATE(3612), 1, + sym_qualified_name, + STATE(1505), 2, sym_comment, sym_include, - ACTIONS(1820), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57326] = 6, - ACTIONS(3), 1, + ACTIONS(1624), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73250] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1822), 1, - ts_builtin_sym_end, - STATE(1164), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2074), 1, + anon_sym_COLON, + STATE(1550), 1, + aux_sym_for_phrase_repeat1, + STATE(1604), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1801), 1, + aux_sym_for_phrase_repeat2, + STATE(2125), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2297), 1, + sym_on_quit_phrase, + STATE(2679), 1, + sym_on_stop_phrase, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(1506), 2, sym_comment, sym_include, - ACTIONS(1824), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [73319] = 20, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57368] = 6, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1545), 1, + sym__pre_tuning, + STATE(1630), 1, + sym_where_clause, + STATE(1631), 1, + aux_sym_for_phrase_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1915), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2315), 1, + sym_on_error_phrase, + STATE(2393), 1, + sym_on_quit_phrase, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1507), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [73386] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1814), 1, - ts_builtin_sym_end, - STATE(1165), 2, + ACTIONS(2078), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1663), 1, + sym_primitive_type, + STATE(1508), 2, sym_comment, sym_include, - ACTIONS(1816), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57410] = 6, - ACTIONS(3), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73429] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1814), 1, - ts_builtin_sym_end, - STATE(1166), 2, + ACTIONS(2084), 1, + aux_sym_variable_definition_token4, + STATE(1509), 2, sym_comment, sym_include, - ACTIONS(1816), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2082), 20, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token1, + aux_sym_buffer_definition_token3, + aux_sym_query_definition_token1, + aux_sym_function_parameter_token1, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_property_definition_token1, + aux_sym_event_definition_token1, + [73468] = 21, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57452] = 6, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(1603), 1, + aux_sym_for_phrase_repeat1, + STATE(1609), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1873), 1, + aux_sym_for_phrase_repeat2, + STATE(2173), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2254), 1, + sym_on_quit_phrase, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 1, + sym_on_stop_phrase, + STATE(1510), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [73537] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1814), 1, - ts_builtin_sym_end, - STATE(1167), 2, + ACTIONS(2078), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1654), 1, + sym_primitive_type, + STATE(1511), 2, sym_comment, sym_include, - ACTIONS(1816), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73580] = 21, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57494] = 6, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2086), 1, + anon_sym_COLON, + STATE(1592), 1, + aux_sym_for_phrase_repeat1, + STATE(1598), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1883), 1, + aux_sym_for_phrase_repeat2, + STATE(2170), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2256), 1, + sym_on_quit_phrase, + STATE(2604), 1, + sym_on_stop_phrase, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(1512), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [73649] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1826), 1, - ts_builtin_sym_end, - STATE(1168), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(3765), 1, + sym_primitive_type, + STATE(1513), 2, sym_comment, sym_include, - ACTIONS(1828), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57536] = 6, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73692] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1830), 1, - ts_builtin_sym_end, - STATE(1169), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(3168), 1, + sym_primitive_type, + STATE(1514), 2, sym_comment, sym_include, - ACTIONS(1832), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57578] = 6, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73735] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1834), 1, - ts_builtin_sym_end, - STATE(1170), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(3750), 1, + sym_primitive_type, + STATE(1515), 2, sym_comment, sym_include, - ACTIONS(1836), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57620] = 6, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73778] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1838), 1, - ts_builtin_sym_end, - STATE(1171), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1961), 1, + sym_primitive_type, + STATE(1516), 2, sym_comment, sym_include, - ACTIONS(1840), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57662] = 24, - ACTIONS(373), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73821] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(1284), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1200), 1, + ACTIONS(2056), 1, anon_sym_COLON, - STATE(1400), 1, - sym_of, - STATE(1431), 1, - sym__pre_tuning, - STATE(1490), 1, - sym_where_clause, - STATE(1495), 1, + STATE(1549), 1, aux_sym_for_phrase_repeat1, - STATE(1575), 1, + STATE(1612), 1, + sym_where_clause, + STATE(1795), 1, sym_query_tuning, - STATE(1669), 1, + STATE(1880), 1, aux_sym_for_phrase_repeat2, - STATE(1908), 1, + STATE(2183), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1996), 1, + STATE(2278), 1, sym_on_quit_phrase, - STATE(2301), 1, + STATE(2636), 1, sym_on_stop_phrase, - STATE(2416), 1, + STATE(2648), 1, aux_sym_for_statement_repeat1, - STATE(1172), 2, + STATE(1517), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [57740] = 6, + [73890] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1842), 1, - ts_builtin_sym_end, - STATE(1173), 2, - sym_comment, - sym_include, - ACTIONS(1844), 23, + ACTIONS(2078), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57782] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1842), 1, - ts_builtin_sym_end, - STATE(1174), 2, + STATE(1495), 1, + sym_qualified_name, + STATE(1668), 1, + sym_primitive_type, + STATE(1518), 2, sym_comment, sym_include, - ACTIONS(1844), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57824] = 6, - ACTIONS(3), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [73933] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1304), 1, - ts_builtin_sym_end, - STATE(1175), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(1585), 1, + sym_where_clause, + STATE(1600), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1859), 1, + aux_sym_for_phrase_repeat2, + STATE(2139), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2263), 1, + sym_on_quit_phrase, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(1519), 2, sym_comment, sym_include, - ACTIONS(1282), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57866] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74002] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1846), 1, - ts_builtin_sym_end, - STATE(1176), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(1557), 1, + sym_where_clause, + STATE(1559), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1819), 1, + aux_sym_for_phrase_repeat2, + STATE(2163), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(1520), 2, sym_comment, sym_include, - ACTIONS(1848), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57908] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74071] = 18, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1850), 1, - ts_builtin_sym_end, - STATE(1177), 2, + ACTIONS(2090), 1, + aux_sym_buffer_definition_token3, + ACTIONS(2092), 1, + aux_sym_function_parameter_token1, + ACTIONS(2096), 1, + aux_sym_property_definition_token1, + ACTIONS(2098), 1, + aux_sym_event_definition_token1, + STATE(1629), 1, + sym_access_tuning, + STATE(1695), 1, + aux_sym_variable_definition_repeat1, + STATE(1769), 1, + sym_scope_tuning, + STATE(1836), 1, + sym_serialization_tuning, + STATE(1976), 1, + aux_sym_property_definition_repeat1, + STATE(2130), 1, + sym_property_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + ACTIONS(2094), 2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + STATE(1521), 2, sym_comment, sym_include, - ACTIONS(1852), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57950] = 6, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [74134] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1854), 1, - ts_builtin_sym_end, - STATE(1178), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(3300), 1, + sym_primitive_type, + STATE(1522), 2, sym_comment, sym_include, - ACTIONS(1856), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [57992] = 6, - ACTIONS(3), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74177] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1858), 1, - ts_builtin_sym_end, - STATE(1179), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2100), 1, + anon_sym_COLON, + STATE(1571), 1, + sym_where_clause, + STATE(1607), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1863), 1, + aux_sym_for_phrase_repeat2, + STATE(2187), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2249), 1, + sym_on_quit_phrase, + STATE(2594), 1, + sym_on_stop_phrase, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(1523), 2, sym_comment, sym_include, - ACTIONS(1860), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58034] = 6, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74246] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1288), 1, - ts_builtin_sym_end, - STATE(1180), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1980), 1, + sym_primitive_type, + STATE(1524), 2, sym_comment, sym_include, - ACTIONS(1290), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58076] = 6, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74289] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1862), 1, - ts_builtin_sym_end, - STATE(1181), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1983), 1, + sym_primitive_type, + STATE(1525), 2, sym_comment, sym_include, - ACTIONS(1864), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58118] = 6, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74332] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1866), 1, - ts_builtin_sym_end, - STATE(1182), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(3214), 1, + sym_primitive_type, + STATE(1526), 2, sym_comment, sym_include, - ACTIONS(1868), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58160] = 6, - ACTIONS(3), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74375] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1870), 1, - ts_builtin_sym_end, - STATE(1183), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2102), 1, + anon_sym_COLON, + STATE(1618), 1, + aux_sym_for_phrase_repeat1, + STATE(1621), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1806), 1, + aux_sym_for_phrase_repeat2, + STATE(2122), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2290), 1, + sym_on_quit_phrase, + STATE(2667), 1, + sym_on_stop_phrase, + STATE(2668), 1, + aux_sym_for_statement_repeat1, + STATE(1527), 2, sym_comment, sym_include, - ACTIONS(1872), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58202] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74444] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1392), 1, - ts_builtin_sym_end, - STATE(1184), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2104), 1, + anon_sym_COLON, + STATE(1551), 1, + sym_where_clause, + STATE(1555), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1864), 1, + aux_sym_for_phrase_repeat2, + STATE(2192), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2319), 1, + sym_on_quit_phrase, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(1528), 2, sym_comment, sym_include, - ACTIONS(1394), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58244] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74513] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1185), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2042), 1, + anon_sym_COLON, + STATE(1567), 1, + sym_where_clause, + STATE(1583), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1832), 1, + aux_sym_for_phrase_repeat2, + STATE(2199), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2242), 1, + sym_on_quit_phrase, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(1529), 2, sym_comment, sym_include, - ACTIONS(1316), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58284] = 5, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74582] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1186), 2, + ACTIONS(2078), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1686), 1, + sym_primitive_type, + STATE(1530), 2, sym_comment, sym_include, - ACTIONS(1776), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58324] = 5, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74625] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1187), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1881), 1, + sym_primitive_type, + STATE(1531), 2, sym_comment, sym_include, - ACTIONS(1724), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58364] = 5, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74668] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1188), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(2007), 1, + sym_primitive_type, + STATE(1532), 2, sym_comment, sym_include, - ACTIONS(1312), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58404] = 5, - ACTIONS(3), 1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [74711] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1189), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2106), 1, + anon_sym_COLON, + STATE(1617), 1, + aux_sym_for_phrase_repeat1, + STATE(1619), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1826), 1, + aux_sym_for_phrase_repeat2, + STATE(2131), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2312), 1, + sym_on_quit_phrase, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 1, + sym_on_stop_phrase, + STATE(1533), 2, sym_comment, sym_include, - ACTIONS(1308), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58444] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74780] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1190), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(1611), 1, + aux_sym_for_phrase_repeat1, + STATE(1613), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1868), 1, + aux_sym_for_phrase_repeat2, + STATE(2124), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2295), 1, + sym_on_quit_phrase, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(1534), 2, sym_comment, sym_include, - ACTIONS(1282), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74849] = 21, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58484] = 5, - ACTIONS(3), 1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2040), 1, + anon_sym_COLON, + STATE(1586), 1, + sym_where_clause, + STATE(1587), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1874), 1, + aux_sym_for_phrase_repeat2, + STATE(2207), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2303), 1, + sym_on_quit_phrase, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, + sym_on_stop_phrase, + STATE(1535), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74918] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1191), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2108), 1, + anon_sym_COLON, + STATE(1560), 1, + sym_where_clause, + STATE(1561), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1822), 1, + aux_sym_for_phrase_repeat2, + STATE(2164), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2352), 1, + sym_on_quit_phrase, + STATE(2759), 1, + sym_on_stop_phrase, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(1536), 2, sym_comment, sym_include, - ACTIONS(1790), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [74987] = 21, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58524] = 5, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2110), 1, + anon_sym_COLON, + STATE(1573), 1, + sym_where_clause, + STATE(1574), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1858), 1, + aux_sym_for_phrase_repeat2, + STATE(2189), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2320), 1, + sym_on_quit_phrase, + STATE(2820), 1, + sym_on_stop_phrase, + STATE(2821), 1, + aux_sym_for_statement_repeat1, + STATE(1537), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75056] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1192), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1967), 1, + sym_primitive_type, + STATE(1538), 2, sym_comment, sym_include, - ACTIONS(1732), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58564] = 5, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [75099] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1193), 2, + ACTIONS(2088), 1, + sym_identifier, + STATE(1495), 1, + sym_qualified_name, + STATE(1958), 1, + sym_primitive_type, + STATE(1539), 2, sym_comment, sym_include, - ACTIONS(1440), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2080), 18, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [75142] = 21, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58604] = 6, - ACTIONS(3), 1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(1590), 1, + aux_sym_for_phrase_repeat1, + STATE(1593), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1852), 1, + aux_sym_for_phrase_repeat2, + STATE(2135), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2308), 1, + sym_on_quit_phrase, + STATE(2691), 1, + aux_sym_for_statement_repeat1, + STATE(2693), 1, + sym_on_stop_phrase, + STATE(1540), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75211] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1874), 1, - ts_builtin_sym_end, - STATE(1194), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2112), 1, + anon_sym_COLON, + STATE(1579), 1, + sym_where_clause, + STATE(1580), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1869), 1, + aux_sym_for_phrase_repeat2, + STATE(2202), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2309), 1, + sym_on_quit_phrase, + STATE(2840), 1, + sym_on_stop_phrase, + STATE(2841), 1, + aux_sym_for_statement_repeat1, + STATE(1541), 2, sym_comment, sym_include, - ACTIONS(1876), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58646] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75280] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1195), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2044), 1, + anon_sym_COLON, + STATE(1577), 1, + sym_where_clause, + STATE(1578), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1866), 1, + aux_sym_for_phrase_repeat2, + STATE(2195), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2310), 1, + sym_on_quit_phrase, + STATE(2833), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(1542), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58688] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75349] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1300), 1, - ts_builtin_sym_end, - STATE(1196), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2050), 1, + anon_sym_COLON, + STATE(1564), 1, + sym_where_clause, + STATE(1565), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1833), 1, + aux_sym_for_phrase_repeat2, + STATE(2171), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(1543), 2, sym_comment, sym_include, - ACTIONS(1302), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58730] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75418] = 21, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1197), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2114), 1, + anon_sym_COLON, + STATE(1553), 1, + sym_where_clause, + STATE(1554), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1814), 1, + aux_sym_for_phrase_repeat2, + STATE(2156), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2347), 1, + sym_on_quit_phrase, + STATE(2747), 1, + sym_on_stop_phrase, + STATE(2749), 1, + aux_sym_for_statement_repeat1, + STATE(1544), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58772] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75487] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1198), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1622), 1, + aux_sym_for_phrase_repeat1, + STATE(1634), 1, + sym_where_clause, + STATE(1795), 1, + sym_query_tuning, + STATE(1942), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2253), 1, + sym_on_error_phrase, + STATE(2453), 1, + sym_on_quit_phrase, + STATE(3098), 1, + sym_on_stop_phrase, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1545), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58814] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75551] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1199), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1284), 1, + aux_sym_where_clause_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1630), 1, + sym_where_clause, + STATE(1631), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1915), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2315), 1, + sym_on_error_phrase, + STATE(2393), 1, + sym_on_quit_phrase, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1546), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58856] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75615] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1306), 1, - ts_builtin_sym_end, - STATE(1200), 2, + ACTIONS(2010), 1, + aux_sym_variable_definition_token3, + ACTIONS(2012), 1, + aux_sym_variable_definition_token4, + ACTIONS(2014), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2016), 1, + aux_sym_buffer_definition_token3, + ACTIONS(2018), 1, + aux_sym_query_definition_token1, + ACTIONS(2022), 1, + aux_sym_stream_definition_token1, + STATE(1645), 1, + aux_sym_variable_definition_repeat1, + STATE(1788), 1, + aux_sym_buffer_definition_repeat1, + STATE(1792), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1547), 2, sym_comment, sym_include, - ACTIONS(1308), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58898] = 6, - ACTIONS(3), 1, + STATE(1711), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [75675] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1201), 2, + ACTIONS(2026), 1, + aux_sym_variable_definition_token3, + ACTIONS(2028), 1, + aux_sym_variable_definition_token4, + ACTIONS(2030), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2032), 1, + aux_sym_buffer_definition_token3, + ACTIONS(2034), 1, + aux_sym_query_definition_token1, + ACTIONS(2038), 1, + aux_sym_stream_definition_token1, + STATE(1650), 1, + aux_sym_variable_definition_repeat1, + STATE(1770), 1, + aux_sym_buffer_definition_repeat1, + STATE(1792), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1548), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58940] = 6, - ACTIONS(3), 1, + STATE(1711), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [75735] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1292), 1, - ts_builtin_sym_end, - STATE(1202), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2104), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1864), 1, + aux_sym_for_phrase_repeat2, + STATE(2192), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2319), 1, + sym_on_quit_phrase, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(1549), 2, sym_comment, sym_include, - ACTIONS(1294), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [58982] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75798] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1878), 1, - ts_builtin_sym_end, - STATE(1203), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2118), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1803), 1, + aux_sym_for_phrase_repeat2, + STATE(2123), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2292), 1, + sym_on_quit_phrase, + STATE(2672), 1, + sym_on_stop_phrase, + STATE(2673), 1, + aux_sym_for_statement_repeat1, + STATE(1550), 2, sym_comment, sym_include, - ACTIONS(1880), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59024] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75861] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1204), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2120), 1, + anon_sym_COLON, + STATE(1596), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1815), 1, + aux_sym_for_phrase_repeat2, + STATE(2128), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2296), 1, + sym_on_quit_phrase, + STATE(2678), 1, + sym_on_stop_phrase, + STATE(2705), 1, + aux_sym_for_statement_repeat1, + STATE(1551), 2, sym_comment, sym_include, - ACTIONS(1780), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59064] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75924] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1205), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2122), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1804), 1, + aux_sym_for_phrase_repeat2, + STATE(2144), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2339), 1, + sym_on_quit_phrase, + STATE(2730), 1, + sym_on_stop_phrase, + STATE(2731), 1, + aux_sym_for_statement_repeat1, + STATE(1552), 2, sym_comment, sym_include, - ACTIONS(1668), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59104] = 24, - ACTIONS(373), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [75987] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1204), 1, + ACTIONS(2124), 1, anon_sym_COLON, - STATE(1398), 1, - sym_of, - STATE(1423), 1, - sym__pre_tuning, - STATE(1450), 1, - sym_where_clause, - STATE(1454), 1, + STATE(1552), 1, aux_sym_for_phrase_repeat1, - STATE(1575), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1650), 1, + STATE(1810), 1, aux_sym_for_phrase_repeat2, - STATE(1882), 1, + STATE(2152), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2031), 1, + STATE(2343), 1, sym_on_quit_phrase, - STATE(2506), 1, + STATE(2737), 1, sym_on_stop_phrase, - STATE(2507), 1, + STATE(2739), 1, aux_sym_for_statement_repeat1, - STATE(1206), 2, + STATE(1553), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [59182] = 6, - ACTIONS(3), 1, + [76050] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1882), 1, - ts_builtin_sym_end, - STATE(1207), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2124), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1810), 1, + aux_sym_for_phrase_repeat2, + STATE(2152), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2343), 1, + sym_on_quit_phrase, + STATE(2737), 1, + sym_on_stop_phrase, + STATE(2739), 1, + aux_sym_for_statement_repeat1, + STATE(1554), 2, sym_comment, sym_include, - ACTIONS(1884), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59224] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76113] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1208), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2120), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1815), 1, + aux_sym_for_phrase_repeat2, + STATE(2128), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2296), 1, + sym_on_quit_phrase, + STATE(2678), 1, + sym_on_stop_phrase, + STATE(2705), 1, + aux_sym_for_statement_repeat1, + STATE(1555), 2, sym_comment, sym_include, - ACTIONS(1402), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59264] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76176] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1209), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2126), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1813), 1, + aux_sym_for_phrase_repeat2, + STATE(2154), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2344), 1, + sym_on_quit_phrase, + STATE(2743), 1, + sym_on_stop_phrase, + STATE(2744), 1, + aux_sym_for_statement_repeat1, + STATE(1556), 2, sym_comment, sym_include, - ACTIONS(1398), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59304] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76239] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1210), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2114), 1, + anon_sym_COLON, + STATE(1554), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1814), 1, + aux_sym_for_phrase_repeat2, + STATE(2156), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2347), 1, + sym_on_quit_phrase, + STATE(2747), 1, + sym_on_stop_phrase, + STATE(2749), 1, + aux_sym_for_statement_repeat1, + STATE(1557), 2, sym_comment, sym_include, - ACTIONS(1482), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59344] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76302] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1211), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(1603), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1873), 1, + aux_sym_for_phrase_repeat2, + STATE(2173), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2254), 1, + sym_on_quit_phrase, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 1, + sym_on_stop_phrase, + STATE(1558), 2, sym_comment, sym_include, - ACTIONS(1514), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59384] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76365] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1212), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2114), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1814), 1, + aux_sym_for_phrase_repeat2, + STATE(2156), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2347), 1, + sym_on_quit_phrase, + STATE(2747), 1, + sym_on_stop_phrase, + STATE(2749), 1, + aux_sym_for_statement_repeat1, + STATE(1559), 2, sym_comment, sym_include, - ACTIONS(1584), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59424] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76428] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1213), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2128), 1, + anon_sym_COLON, + STATE(1556), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1817), 1, + aux_sym_for_phrase_repeat2, + STATE(2159), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2348), 1, + sym_on_quit_phrase, + STATE(2751), 1, + sym_on_stop_phrase, + STATE(2752), 1, + aux_sym_for_statement_repeat1, + STATE(1560), 2, sym_comment, sym_include, - ACTIONS(1696), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59464] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76491] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1214), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2128), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1817), 1, + aux_sym_for_phrase_repeat2, + STATE(2159), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2348), 1, + sym_on_quit_phrase, + STATE(2751), 1, + sym_on_stop_phrase, + STATE(2752), 1, + aux_sym_for_statement_repeat1, + STATE(1561), 2, sym_comment, sym_include, - ACTIONS(1216), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59504] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76554] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1215), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1819), 1, + aux_sym_for_phrase_repeat2, + STATE(2163), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(1562), 2, sym_comment, sym_include, - ACTIONS(1380), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59544] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76617] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1216), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(1559), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1819), 1, + aux_sym_for_phrase_repeat2, + STATE(2163), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(1563), 2, sym_comment, sym_include, - ACTIONS(1376), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59584] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76680] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1217), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2108), 1, + anon_sym_COLON, + STATE(1561), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1822), 1, + aux_sym_for_phrase_repeat2, + STATE(2164), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2352), 1, + sym_on_quit_phrase, + STATE(2759), 1, + sym_on_stop_phrase, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(1564), 2, sym_comment, sym_include, - ACTIONS(1372), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59624] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76743] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1218), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2108), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1822), 1, + aux_sym_for_phrase_repeat2, + STATE(2164), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2352), 1, + sym_on_quit_phrase, + STATE(2759), 1, + sym_on_stop_phrase, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(1565), 2, sym_comment, sym_include, - ACTIONS(1280), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59664] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76806] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1219), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2050), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1833), 1, + aux_sym_for_phrase_repeat2, + STATE(2171), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(1566), 2, sym_comment, sym_include, - ACTIONS(1276), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59704] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76869] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1220), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2106), 1, + anon_sym_COLON, + STATE(1617), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1826), 1, + aux_sym_for_phrase_repeat2, + STATE(2131), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2312), 1, + sym_on_quit_phrase, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 1, + sym_on_stop_phrase, + STATE(1567), 2, sym_comment, sym_include, - ACTIONS(1272), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59744] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76932] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1221), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2050), 1, + anon_sym_COLON, + STATE(1565), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1833), 1, + aux_sym_for_phrase_repeat2, + STATE(2171), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(1568), 2, sym_comment, sym_include, - ACTIONS(1268), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [76995] = 19, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59784] = 5, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2130), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1842), 1, + aux_sym_for_phrase_repeat2, + STATE(2198), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2243), 1, + sym_on_quit_phrase, + STATE(2573), 1, + sym_on_stop_phrase, + STATE(2574), 1, + aux_sym_for_statement_repeat1, + STATE(1569), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77058] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1222), 2, + STATE(1570), 2, sym_comment, sym_include, - ACTIONS(1806), 24, + ACTIONS(2084), 19, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59824] = 5, - ACTIONS(3), 1, + aux_sym_primitive_type_token1, + aux_sym_primitive_type_token2, + aux_sym_primitive_type_token3, + aux_sym_primitive_type_token4, + aux_sym_primitive_type_token5, + aux_sym_primitive_type_token6, + aux_sym_primitive_type_token7, + aux_sym_primitive_type_token8, + aux_sym_primitive_type_token9, + aux_sym_primitive_type_token10, + aux_sym_primitive_type_token11, + aux_sym_primitive_type_token12, + aux_sym_primitive_type_token13, + aux_sym_primitive_type_token14, + aux_sym_primitive_type_token15, + aux_sym_primitive_type_token16, + aux_sym_primitive_type_token17, + aux_sym_primitive_type_token18, + [77093] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1223), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2132), 1, + anon_sym_COLON, + STATE(1569), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1843), 1, + aux_sym_for_phrase_repeat2, + STATE(2194), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2245), 1, + sym_on_quit_phrase, + STATE(2589), 1, + sym_on_stop_phrase, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(1571), 2, sym_comment, sym_include, - ACTIONS(1820), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59864] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77156] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1224), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2134), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1851), 1, + aux_sym_for_phrase_repeat2, + STATE(2179), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2327), 1, + sym_on_quit_phrase, + STATE(2805), 1, + sym_on_stop_phrase, + STATE(2806), 1, + aux_sym_for_statement_repeat1, + STATE(1572), 2, sym_comment, sym_include, - ACTIONS(1368), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59904] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77219] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1225), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2136), 1, + anon_sym_COLON, + STATE(1572), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1854), 1, + aux_sym_for_phrase_repeat2, + STATE(2184), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2324), 1, + sym_on_quit_phrase, + STATE(2813), 1, + sym_on_stop_phrase, + STATE(2814), 1, + aux_sym_for_statement_repeat1, + STATE(1573), 2, sym_comment, sym_include, - ACTIONS(1364), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59944] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77282] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1226), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2136), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1854), 1, + aux_sym_for_phrase_repeat2, + STATE(2184), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2324), 1, + sym_on_quit_phrase, + STATE(2813), 1, + sym_on_stop_phrase, + STATE(2814), 1, + aux_sym_for_statement_repeat1, + STATE(1574), 2, sym_comment, sym_include, - ACTIONS(1836), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [59984] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77345] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1227), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2138), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1856), 1, + aux_sym_for_phrase_repeat2, + STATE(2188), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2322), 1, + sym_on_quit_phrase, + STATE(2816), 1, + sym_on_stop_phrase, + STATE(2817), 1, + aux_sym_for_statement_repeat1, + STATE(1575), 2, sym_comment, sym_include, - ACTIONS(1886), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60024] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77408] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1888), 1, - ts_builtin_sym_end, - STATE(1228), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(1600), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1859), 1, + aux_sym_for_phrase_repeat2, + STATE(2139), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2263), 1, + sym_on_quit_phrase, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(1576), 2, sym_comment, sym_include, - ACTIONS(1886), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60066] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77471] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1229), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2110), 1, + anon_sym_COLON, + STATE(1574), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1858), 1, + aux_sym_for_phrase_repeat2, + STATE(2189), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2320), 1, + sym_on_quit_phrase, + STATE(2820), 1, + sym_on_stop_phrase, + STATE(2821), 1, + aux_sym_for_statement_repeat1, + STATE(1577), 2, sym_comment, sym_include, - ACTIONS(1890), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60106] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77534] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1230), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2110), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1858), 1, + aux_sym_for_phrase_repeat2, + STATE(2189), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2320), 1, + sym_on_quit_phrase, + STATE(2820), 1, + sym_on_stop_phrase, + STATE(2821), 1, + aux_sym_for_statement_repeat1, + STATE(1578), 2, sym_comment, sym_include, - ACTIONS(1892), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77597] = 19, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60146] = 5, - ACTIONS(3), 1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2140), 1, + anon_sym_COLON, + STATE(1575), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1862), 1, + aux_sym_for_phrase_repeat2, + STATE(2191), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2318), 1, + sym_on_quit_phrase, + STATE(2830), 1, + sym_on_stop_phrase, + STATE(2831), 1, + aux_sym_for_statement_repeat1, + STATE(1579), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77660] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1231), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2140), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1862), 1, + aux_sym_for_phrase_repeat2, + STATE(2191), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2318), 1, + sym_on_quit_phrase, + STATE(2830), 1, + sym_on_stop_phrase, + STATE(2831), 1, + aux_sym_for_statement_repeat1, + STATE(1580), 2, sym_comment, sym_include, - ACTIONS(1360), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60186] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77723] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1232), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2044), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1866), 1, + aux_sym_for_phrase_repeat2, + STATE(2195), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2310), 1, + sym_on_quit_phrase, + STATE(2833), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(1581), 2, sym_comment, sym_include, - ACTIONS(1894), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60226] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77786] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1233), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1873), 1, + aux_sym_for_phrase_repeat2, + STATE(2173), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2254), 1, + sym_on_quit_phrase, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 1, + sym_on_stop_phrase, + STATE(1582), 2, sym_comment, sym_include, - ACTIONS(1896), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60266] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77849] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1234), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2106), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1826), 1, + aux_sym_for_phrase_repeat2, + STATE(2131), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2312), 1, + sym_on_quit_phrase, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 1, + sym_on_stop_phrase, + STATE(1583), 2, sym_comment, sym_include, - ACTIONS(1898), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60306] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77912] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1235), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2044), 1, + anon_sym_COLON, + STATE(1578), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1866), 1, + aux_sym_for_phrase_repeat2, + STATE(2195), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2310), 1, + sym_on_quit_phrase, + STATE(2833), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(1584), 2, sym_comment, sym_include, - ACTIONS(1900), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60346] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [77975] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1296), 1, - ts_builtin_sym_end, - STATE(1236), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2086), 1, + anon_sym_COLON, + STATE(1592), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1883), 1, + aux_sym_for_phrase_repeat2, + STATE(2170), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2256), 1, + sym_on_quit_phrase, + STATE(2604), 1, + sym_on_stop_phrase, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(1585), 2, sym_comment, sym_include, - ACTIONS(1298), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60388] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78038] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1237), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2112), 1, + anon_sym_COLON, + STATE(1580), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1869), 1, + aux_sym_for_phrase_repeat2, + STATE(2202), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2309), 1, + sym_on_quit_phrase, + STATE(2840), 1, + sym_on_stop_phrase, + STATE(2841), 1, + aux_sym_for_statement_repeat1, + STATE(1586), 2, sym_comment, sym_include, - ACTIONS(1720), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60428] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78101] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1238), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2112), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1869), 1, + aux_sym_for_phrase_repeat2, + STATE(2202), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2309), 1, + sym_on_quit_phrase, + STATE(2840), 1, + sym_on_stop_phrase, + STATE(2841), 1, + aux_sym_for_statement_repeat1, + STATE(1587), 2, sym_comment, sym_include, - ACTIONS(1356), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60468] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78164] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1239), 2, - sym_comment, - sym_include, - ACTIONS(1708), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60508] = 5, - ACTIONS(3), 1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(1590), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1852), 1, + aux_sym_for_phrase_repeat2, + STATE(2135), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2308), 1, + sym_on_quit_phrase, + STATE(2691), 1, + aux_sym_for_statement_repeat1, + STATE(2693), 1, + sym_on_stop_phrase, + STATE(1588), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78227] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1240), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1852), 1, + aux_sym_for_phrase_repeat2, + STATE(2135), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2308), 1, + sym_on_quit_phrase, + STATE(2691), 1, + aux_sym_for_statement_repeat1, + STATE(2693), 1, + sym_on_stop_phrase, + STATE(1589), 2, sym_comment, sym_include, - ACTIONS(1352), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60548] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78290] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1241), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2074), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1801), 1, + aux_sym_for_phrase_repeat2, + STATE(2125), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2297), 1, + sym_on_quit_phrase, + STATE(2679), 1, + sym_on_stop_phrase, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(1590), 2, sym_comment, sym_include, - ACTIONS(1876), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60588] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78353] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1242), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2040), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1874), 1, + aux_sym_for_phrase_repeat2, + STATE(2207), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2303), 1, + sym_on_quit_phrase, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, + sym_on_stop_phrase, + STATE(1591), 2, sym_comment, sym_include, - ACTIONS(1872), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60628] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78416] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1243), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2142), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1871), 1, + aux_sym_for_phrase_repeat2, + STATE(2185), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2250), 1, + sym_on_quit_phrase, + STATE(2596), 1, + sym_on_stop_phrase, + STATE(2597), 1, + aux_sym_for_statement_repeat1, + STATE(1592), 2, sym_comment, sym_include, - ACTIONS(1840), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60668] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78479] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1244), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2074), 1, + anon_sym_COLON, + STATE(1550), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1801), 1, + aux_sym_for_phrase_repeat2, + STATE(2125), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2297), 1, + sym_on_quit_phrase, + STATE(2679), 1, + sym_on_stop_phrase, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(1593), 2, sym_comment, sym_include, - ACTIONS(1264), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60708] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78542] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1245), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2040), 1, + anon_sym_COLON, + STATE(1587), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1874), 1, + aux_sym_for_phrase_repeat2, + STATE(2207), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2303), 1, + sym_on_quit_phrase, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, + sym_on_stop_phrase, + STATE(1594), 2, sym_comment, sym_include, - ACTIONS(1680), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60748] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78605] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1246), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(1611), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1868), 1, + aux_sym_for_phrase_repeat2, + STATE(2124), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2295), 1, + sym_on_quit_phrase, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(1595), 2, sym_comment, sym_include, - ACTIONS(1676), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60788] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78668] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1902), 1, - ts_builtin_sym_end, - STATE(1247), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2144), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1818), 1, + aux_sym_for_phrase_repeat2, + STATE(2157), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2345), 1, + sym_on_quit_phrase, + STATE(2735), 1, + aux_sym_for_statement_repeat1, + STATE(2745), 1, + sym_on_stop_phrase, + STATE(1596), 2, sym_comment, sym_include, - ACTIONS(1890), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60830] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78731] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1248), 2, - sym_comment, - sym_include, - ACTIONS(1736), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60870] = 5, - ACTIONS(3), 1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2146), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1877), 1, + aux_sym_for_phrase_repeat2, + STATE(2155), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2337), 1, + sym_on_quit_phrase, + STATE(2763), 1, + sym_on_stop_phrase, + STATE(2789), 1, + aux_sym_for_statement_repeat1, + STATE(1597), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78794] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1249), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2142), 1, + anon_sym_COLON, + STATE(1616), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1871), 1, + aux_sym_for_phrase_repeat2, + STATE(2185), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2250), 1, + sym_on_quit_phrase, + STATE(2596), 1, + sym_on_stop_phrase, + STATE(2597), 1, + aux_sym_for_statement_repeat1, + STATE(1598), 2, sym_comment, sym_include, - ACTIONS(1728), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60910] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78857] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1250), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1868), 1, + aux_sym_for_phrase_repeat2, + STATE(2124), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2295), 1, + sym_on_quit_phrase, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(1599), 2, sym_comment, sym_include, - ACTIONS(1348), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60950] = 6, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78920] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1904), 1, - ts_builtin_sym_end, - STATE(1251), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2086), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1883), 1, + aux_sym_for_phrase_repeat2, + STATE(2170), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2256), 1, + sym_on_quit_phrase, + STATE(2604), 1, + sym_on_stop_phrase, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(1600), 2, sym_comment, sym_include, - ACTIONS(1812), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [60992] = 24, - ACTIONS(373), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [78983] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1188), 1, - anon_sym_COLON, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1408), 1, - sym_of, - STATE(1420), 1, - sym__pre_tuning, - STATE(1474), 1, - sym_where_clause, - STATE(1494), 1, + ACTIONS(2042), 1, + anon_sym_COLON, + STATE(1694), 1, aux_sym_for_phrase_repeat1, - STATE(1575), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1640), 1, + STATE(1832), 1, aux_sym_for_phrase_repeat2, - STATE(1906), 1, + STATE(2199), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1973), 1, + STATE(2242), 1, sym_on_quit_phrase, - STATE(2402), 1, - sym_on_stop_phrase, - STATE(2471), 1, + STATE(2556), 1, aux_sym_for_statement_repeat1, - STATE(1252), 2, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(1601), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [61070] = 5, - ACTIONS(3), 1, + [79046] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1253), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2056), 1, + anon_sym_COLON, + STATE(1549), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1880), 1, + aux_sym_for_phrase_repeat2, + STATE(2183), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2278), 1, + sym_on_quit_phrase, + STATE(2636), 1, + sym_on_stop_phrase, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(1602), 2, sym_comment, sym_include, - ACTIONS(1260), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61110] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79109] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1254), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2100), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1863), 1, + aux_sym_for_phrase_repeat2, + STATE(2187), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2249), 1, + sym_on_quit_phrase, + STATE(2594), 1, + sym_on_stop_phrase, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(1603), 2, sym_comment, sym_include, - ACTIONS(1260), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61150] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79172] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1255), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2118), 1, + anon_sym_COLON, + STATE(1614), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1803), 1, + aux_sym_for_phrase_repeat2, + STATE(2123), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2292), 1, + sym_on_quit_phrase, + STATE(2672), 1, + sym_on_stop_phrase, + STATE(2673), 1, + aux_sym_for_statement_repeat1, + STATE(1604), 2, sym_comment, sym_include, - ACTIONS(1260), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61190] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79235] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1256), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2042), 1, + anon_sym_COLON, + STATE(1583), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1832), 1, + aux_sym_for_phrase_repeat2, + STATE(2199), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2242), 1, + sym_on_quit_phrase, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(1605), 2, sym_comment, sym_include, - ACTIONS(1260), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61230] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79298] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1257), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1859), 1, + aux_sym_for_phrase_repeat2, + STATE(2139), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2263), 1, + sym_on_quit_phrase, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(1606), 2, sym_comment, sym_include, - ACTIONS(1256), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61270] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79361] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1258), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2132), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1843), 1, + aux_sym_for_phrase_repeat2, + STATE(2194), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2245), 1, + sym_on_quit_phrase, + STATE(2589), 1, + sym_on_stop_phrase, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(1607), 2, sym_comment, sym_include, - ACTIONS(1612), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61310] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79424] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1259), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2056), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1880), 1, + aux_sym_for_phrase_repeat2, + STATE(2183), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2278), 1, + sym_on_quit_phrase, + STATE(2636), 1, + sym_on_stop_phrase, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(1608), 2, sym_comment, sym_include, - ACTIONS(1596), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61350] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79487] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1260), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2100), 1, + anon_sym_COLON, + STATE(1607), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1863), 1, + aux_sym_for_phrase_repeat2, + STATE(2187), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2249), 1, + sym_on_quit_phrase, + STATE(2594), 1, + sym_on_stop_phrase, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(1609), 2, sym_comment, sym_include, - ACTIONS(1252), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61390] = 6, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79550] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1906), 1, - ts_builtin_sym_end, - STATE(1261), 2, - sym_comment, - sym_include, - ACTIONS(1892), 23, + ACTIONS(2148), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2150), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + ACTIONS(2152), 1, aux_sym_if_statement_token1, + ACTIONS(2154), 1, aux_sym_repeat_statement_token1, + ACTIONS(2156), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2158), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61432] = 5, - ACTIONS(3), 1, + STATE(1097), 1, + sym__terminated_statement, + STATE(1101), 1, + sym_do_block, + STATE(2557), 1, + sym_label, + STATE(3558), 1, + sym_function_call, + STATE(3675), 1, + sym_assignment, + STATE(1022), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1610), 2, + sym_comment, + sym_include, + STATE(1099), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [79609] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1262), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2102), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1806), 1, + aux_sym_for_phrase_repeat2, + STATE(2122), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2290), 1, + sym_on_quit_phrase, + STATE(2667), 1, + sym_on_stop_phrase, + STATE(2668), 1, + aux_sym_for_statement_repeat1, + STATE(1611), 2, sym_comment, sym_include, - ACTIONS(1558), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61472] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79672] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1263), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2104), 1, + anon_sym_COLON, + STATE(1555), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1864), 1, + aux_sym_for_phrase_repeat2, + STATE(2192), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2319), 1, + sym_on_quit_phrase, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(1612), 2, sym_comment, sym_include, - ACTIONS(1554), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61512] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79735] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1264), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2102), 1, + anon_sym_COLON, + STATE(1618), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1806), 1, + aux_sym_for_phrase_repeat2, + STATE(2122), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2290), 1, + sym_on_quit_phrase, + STATE(2667), 1, + sym_on_stop_phrase, + STATE(2668), 1, + aux_sym_for_statement_repeat1, + STATE(1613), 2, sym_comment, sym_include, - ACTIONS(1546), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61552] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79798] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1265), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2160), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1808), 1, + aux_sym_for_phrase_repeat2, + STATE(2120), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2288), 1, + sym_on_quit_phrase, + STATE(2664), 1, + sym_on_stop_phrase, + STATE(2665), 1, + aux_sym_for_statement_repeat1, + STATE(1614), 2, sym_comment, sym_include, - ACTIONS(1542), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61592] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79861] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1266), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2162), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1812), 1, + aux_sym_for_phrase_repeat2, + STATE(2140), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2285), 1, + sym_on_quit_phrase, + STATE(2658), 1, + sym_on_stop_phrase, + STATE(2659), 1, + aux_sym_for_statement_repeat1, + STATE(1615), 2, sym_comment, sym_include, - ACTIONS(1530), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61632] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79924] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1267), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2164), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1844), 1, + aux_sym_for_phrase_repeat2, + STATE(2193), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2247), 1, + sym_on_quit_phrase, + STATE(2591), 1, + sym_on_stop_phrase, + STATE(2592), 1, + aux_sym_for_statement_repeat1, + STATE(1616), 2, sym_comment, sym_include, - ACTIONS(1526), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61672] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [79987] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1268), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2166), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1861), 1, + aux_sym_for_phrase_repeat2, + STATE(2210), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2300), 1, + sym_on_quit_phrase, + STATE(2862), 1, + aux_sym_for_statement_repeat1, + STATE(2864), 1, + sym_on_stop_phrase, + STATE(1617), 2, sym_comment, sym_include, - ACTIONS(1522), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61712] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80050] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1269), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2168), 1, + anon_sym_COLON, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1809), 1, + aux_sym_for_phrase_repeat2, + STATE(2110), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2287), 1, + sym_on_quit_phrase, + STATE(2662), 1, + sym_on_stop_phrase, + STATE(2663), 1, + aux_sym_for_statement_repeat1, + STATE(1618), 2, sym_comment, sym_include, - ACTIONS(1538), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61752] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80113] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1270), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2166), 1, + anon_sym_COLON, + STATE(1597), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1861), 1, + aux_sym_for_phrase_repeat2, + STATE(2210), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2300), 1, + sym_on_quit_phrase, + STATE(2862), 1, + aux_sym_for_statement_repeat1, + STATE(2864), 1, + sym_on_stop_phrase, + STATE(1619), 2, sym_comment, sym_include, - ACTIONS(1518), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61792] = 5, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80176] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1271), 2, - sym_comment, - sym_include, - ACTIONS(1478), 24, + ACTIONS(2170), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2172), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, + ACTIONS(2174), 1, aux_sym_if_statement_token1, + ACTIONS(2176), 1, aux_sym_repeat_statement_token1, + ACTIONS(2178), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2180), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61832] = 5, - ACTIONS(3), 1, + STATE(941), 1, + sym_do_block, + STATE(943), 1, + sym__terminated_statement, + STATE(2529), 1, + sym_label, + STATE(3436), 1, + sym_function_call, + STATE(3439), 1, + sym_assignment, + STATE(935), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1620), 2, + sym_comment, + sym_include, + STATE(942), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [80235] = 19, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1272), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2168), 1, + anon_sym_COLON, + STATE(1615), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1809), 1, + aux_sym_for_phrase_repeat2, + STATE(2110), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2287), 1, + sym_on_quit_phrase, + STATE(2662), 1, + sym_on_stop_phrase, + STATE(2663), 1, + aux_sym_for_statement_repeat1, + STATE(1621), 2, sym_comment, sym_include, - ACTIONS(1248), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61872] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80298] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1273), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1939), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2265), 1, + sym_on_error_phrase, + STATE(2435), 1, + sym_on_quit_phrase, + STATE(3137), 1, + sym_on_stop_phrase, + ACTIONS(2182), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1622), 2, sym_comment, sym_include, - ACTIONS(1498), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61912] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80356] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1274), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1915), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2315), 1, + sym_on_error_phrase, + STATE(2393), 1, + sym_on_quit_phrase, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1623), 2, sym_comment, sym_include, - ACTIONS(1660), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61952] = 5, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80414] = 16, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1275), 2, - sym_comment, - sym_include, - ACTIONS(1656), 24, + ACTIONS(2148), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2150), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2154), 1, aux_sym_repeat_statement_token1, + ACTIONS(2156), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2158), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [61992] = 6, - ACTIONS(3), 1, + STATE(1097), 1, + sym__terminated_statement, + STATE(1101), 1, + sym_do_block, + STATE(2557), 1, + sym_label, + STATE(3558), 1, + sym_function_call, + STATE(3675), 1, + sym_assignment, + STATE(1100), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1624), 2, + sym_comment, + sym_include, + STATE(1099), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [80470] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1908), 1, - ts_builtin_sym_end, - STATE(1276), 2, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1625), 2, sym_comment, sym_include, - ACTIONS(1910), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2184), 16, + sym__terminator, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62034] = 5, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + aux_sym_of_token1, + aux_sym__using_first_token1, + [80508] = 16, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1277), 2, - sym_comment, - sym_include, - ACTIONS(1632), 24, + ACTIONS(2170), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2172), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2176), 1, aux_sym_repeat_statement_token1, + ACTIONS(2178), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2180), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + STATE(941), 1, + sym_do_block, + STATE(943), 1, + sym__terminated_statement, + STATE(2529), 1, + sym_label, + STATE(3436), 1, + sym_function_call, + STATE(3439), 1, + sym_assignment, + STATE(934), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1626), 2, + sym_comment, + sym_include, + STATE(942), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [80564] = 17, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62074] = 6, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1940), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2255), 1, + sym_on_error_phrase, + STATE(2451), 1, + sym_on_quit_phrase, + STATE(3086), 1, + sym_on_stop_phrase, + ACTIONS(2186), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1627), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80622] = 16, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1386), 1, - ts_builtin_sym_end, - STATE(1278), 2, - sym_comment, - sym_include, - ACTIONS(1388), 23, + ACTIONS(2170), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2172), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2176), 1, aux_sym_repeat_statement_token1, + ACTIONS(2178), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2180), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62116] = 6, - ACTIONS(3), 1, + STATE(941), 1, + sym_do_block, + STATE(943), 1, + sym__terminated_statement, + STATE(2529), 1, + sym_label, + STATE(3436), 1, + sym_function_call, + STATE(3439), 1, + sym_assignment, + STATE(870), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1628), 2, + sym_comment, + sym_include, + STATE(942), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [80678] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1912), 1, - ts_builtin_sym_end, - STATE(1279), 2, + ACTIONS(2193), 1, + aux_sym_function_parameter_token1, + ACTIONS(2195), 1, + aux_sym_property_definition_token1, + ACTIONS(2197), 1, + aux_sym_event_definition_token1, + STATE(1974), 1, + aux_sym_property_definition_repeat1, + STATE(2130), 1, + sym_property_tuning, + STATE(3539), 1, + sym_serialization_tuning, + ACTIONS(2094), 2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + ACTIONS(2190), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1629), 2, sym_comment, sym_include, - ACTIONS(1914), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62158] = 5, - ACTIONS(3), 1, + ACTIONS(2188), 8, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_buffer_definition_token3, + [80728] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1280), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1622), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1942), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2253), 1, + sym_on_error_phrase, + STATE(2453), 1, + sym_on_quit_phrase, + STATE(3098), 1, + sym_on_stop_phrase, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1630), 2, sym_comment, sym_include, - ACTIONS(1506), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80786] = 17, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62198] = 5, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1942), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2253), 1, + sym_on_error_phrase, + STATE(2453), 1, + sym_on_quit_phrase, + STATE(3098), 1, + sym_on_stop_phrase, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1631), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80844] = 16, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1281), 2, - sym_comment, - sym_include, - ACTIONS(1510), 24, + ACTIONS(2148), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2150), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2154), 1, aux_sym_repeat_statement_token1, + ACTIONS(2156), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2158), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62238] = 5, - ACTIONS(3), 1, + STATE(1097), 1, + sym__terminated_statement, + STATE(1101), 1, + sym_do_block, + STATE(2557), 1, + sym_label, + STATE(3558), 1, + sym_function_call, + STATE(3675), 1, + sym_assignment, + STATE(883), 2, + sym__if_do_variant, + sym__if_then_variant, + STATE(1632), 2, + sym_comment, + sym_include, + STATE(1099), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [80900] = 17, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1282), 2, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1631), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1915), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2315), 1, + sym_on_error_phrase, + STATE(2393), 1, + sym_on_quit_phrase, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1633), 2, sym_comment, sym_include, - ACTIONS(1436), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [80958] = 17, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62278] = 5, - ACTIONS(3), 1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + STATE(1627), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1939), 1, + aux_sym_for_phrase_repeat2, + STATE(2227), 1, + sym_sort_clause, + STATE(2265), 1, + sym_on_error_phrase, + STATE(2435), 1, + sym_on_quit_phrase, + STATE(3137), 1, + sym_on_stop_phrase, + ACTIONS(2182), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1634), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81016] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1283), 2, + ACTIONS(2201), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2203), 1, + aux_sym_variable_definition_token2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2209), 1, + aux_sym_property_definition_token2, + ACTIONS(2211), 1, + sym__namedot, + STATE(1758), 1, + aux_sym_qualified_name_repeat1, + STATE(1759), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1635), 2, sym_comment, sym_include, - ACTIONS(1444), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2199), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62318] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [81071] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1284), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2211), 1, + sym__namedot, + ACTIONS(2215), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2217), 1, + aux_sym_variable_definition_token2, + ACTIONS(2219), 1, + aux_sym_property_definition_token2, + STATE(1730), 1, + aux_sym_property_definition_repeat2, + STATE(1758), 1, + aux_sym_qualified_name_repeat1, + STATE(3184), 1, + sym_access_tuning, + STATE(1636), 2, sym_comment, sym_include, - ACTIONS(1474), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2213), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62358] = 5, + aux_sym_method_definition_token1, + [81126] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1285), 2, - sym_comment, - sym_include, - ACTIONS(1502), 24, + ACTIONS(2221), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2223), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2225), 1, aux_sym_repeat_statement_token1, + ACTIONS(2227), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2229), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62398] = 5, + STATE(2524), 1, + sym_label, + STATE(2615), 1, + sym__case_branch_body, + STATE(3519), 1, + sym_assignment, + STATE(3522), 1, + sym_function_call, + STATE(1637), 2, + sym_comment, + sym_include, + STATE(2601), 2, + sym__terminated_statement, + sym_do_block, + STATE(2627), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [81179] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1286), 2, - sym_comment, - sym_include, - ACTIONS(1244), 24, + ACTIONS(2221), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, + ACTIONS(2223), 1, aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, + ACTIONS(2225), 1, aux_sym_repeat_statement_token1, + ACTIONS(2227), 1, aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, + ACTIONS(2229), 1, aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62438] = 6, - ACTIONS(3), 1, + STATE(2524), 1, + sym_label, + STATE(3519), 1, + sym_assignment, + STATE(3522), 1, + sym_function_call, + STATE(3610), 1, + sym__case_branch_body, + STATE(1638), 2, + sym_comment, + sym_include, + STATE(2601), 2, + sym__terminated_statement, + sym_do_block, + STATE(2627), 6, + sym_variable_assignment, + sym_function_call_statement, + sym_repeat_statement, + sym_return_statement, + sym_for_statement, + sym_abl_statement, + [81232] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1382), 1, - ts_builtin_sym_end, - STATE(1287), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2211), 1, + sym__namedot, + ACTIONS(2233), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2235), 1, + aux_sym_variable_definition_token2, + ACTIONS(2237), 1, + aux_sym_property_definition_token2, + STATE(1745), 1, + aux_sym_property_definition_repeat2, + STATE(1758), 1, + aux_sym_qualified_name_repeat1, + STATE(3184), 1, + sym_access_tuning, + STATE(1639), 2, sym_comment, sym_include, - ACTIONS(1384), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62480] = 5, - ACTIONS(3), 1, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2231), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [81287] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1288), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2211), 1, + sym__namedot, + ACTIONS(2241), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2243), 1, + aux_sym_variable_definition_token2, + ACTIONS(2245), 1, + aux_sym_property_definition_token2, + STATE(1723), 1, + aux_sym_property_definition_repeat2, + STATE(1758), 1, + aux_sym_qualified_name_repeat1, + STATE(3184), 1, + sym_access_tuning, + STATE(1640), 2, sym_comment, sym_include, - ACTIONS(1628), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2239), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62520] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [81342] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1289), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2247), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1787), 1, + sym_of, + STATE(1798), 1, + sym__pre_tuning, + STATE(1987), 1, + sym_where_clause, + STATE(1996), 1, + aux_sym_for_phrase_repeat1, + STATE(1641), 2, sym_comment, sym_include, - ACTIONS(1344), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62560] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81396] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1290), 2, + STATE(1642), 2, sym_comment, sym_include, - ACTIONS(1534), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2249), 16, + sym__terminator, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62600] = 6, - ACTIONS(3), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + aux_sym_of_token1, + aux_sym__using_first_token1, + [81428] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1916), 1, - ts_builtin_sym_end, - STATE(1291), 2, + ACTIONS(2262), 1, + aux_sym_variable_definition_token4, + ACTIONS(2257), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + ACTIONS(2260), 2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token3, + ACTIONS(2254), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1643), 3, sym_comment, sym_include, - ACTIONS(1894), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62642] = 6, - ACTIONS(3), 1, + aux_sym_variable_definition_repeat1, + STATE(1792), 3, + sym_scope_tuning, + sym_access_tuning, + sym_serialization_tuning, + ACTIONS(2251), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [81470] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1918), 1, - ts_builtin_sym_end, - STATE(1292), 2, + STATE(1644), 2, sym_comment, sym_include, - ACTIONS(1920), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2264), 16, + sym__terminator, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62684] = 5, - ACTIONS(3), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + aux_sym_of_token1, + aux_sym__using_first_token1, + [81502] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1293), 2, + ACTIONS(2266), 1, + aux_sym_variable_definition_token3, + ACTIONS(2268), 1, + aux_sym_variable_definition_token4, + ACTIONS(2270), 1, + aux_sym_buffer_definition_token3, + STATE(1643), 1, + aux_sym_variable_definition_repeat1, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1645), 2, sym_comment, sym_include, - ACTIONS(1608), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62724] = 6, - ACTIONS(3), 1, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1792), 3, + sym_scope_tuning, + sym_access_tuning, + sym_serialization_tuning, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [81548] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1922), 1, - ts_builtin_sym_end, - STATE(1294), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2272), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1783), 1, + sym_of, + STATE(1885), 1, + sym__pre_tuning, + STATE(2008), 1, + aux_sym_for_phrase_repeat1, + STATE(2009), 1, + sym_where_clause, + STATE(1646), 2, sym_comment, sym_include, - ACTIONS(1924), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62766] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81602] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1295), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2276), 1, + anon_sym_COLON, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1696), 1, + aux_sym_class_statement_repeat1, + STATE(1647), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62806] = 5, - ACTIONS(3), 1, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [81654] = 16, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1296), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2288), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1772), 1, + sym_of, + STATE(1840), 1, + sym__pre_tuning, + STATE(1956), 1, + aux_sym_for_phrase_repeat1, + STATE(1991), 1, + sym_where_clause, + STATE(1648), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62846] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81708] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1297), 2, + STATE(1649), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2184), 16, + sym__terminator, + anon_sym_RPAREN, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62886] = 5, - ACTIONS(3), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + aux_sym_of_token1, + aux_sym__using_first_token1, + [81740] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2290), 1, + aux_sym_variable_definition_token3, + ACTIONS(2292), 1, + aux_sym_variable_definition_token4, + ACTIONS(2294), 1, + aux_sym_buffer_definition_token3, + STATE(1643), 1, + aux_sym_variable_definition_repeat1, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1650), 2, + sym_comment, + sym_include, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1792), 3, + sym_scope_tuning, + sym_access_tuning, + sym_serialization_tuning, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [81786] = 16, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2296), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1720), 1, + sym_query_tuning, + STATE(1789), 1, + sym_of, + STATE(1865), 1, + sym__pre_tuning, + STATE(1994), 1, + sym_where_clause, + STATE(1998), 1, + aux_sym_for_phrase_repeat1, + STATE(1651), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81840] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1298), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + ACTIONS(2298), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1709), 1, + aux_sym_class_statement_repeat1, + STATE(1652), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62926] = 5, - ACTIONS(3), 1, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [81892] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1299), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2300), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1653), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [62966] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [81939] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1300), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2304), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2306), 1, + aux_sym_variable_definition_token2, + ACTIONS(2308), 1, + aux_sym_property_definition_token2, + STATE(1734), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1654), 2, sym_comment, sym_include, - ACTIONS(1240), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2302), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63006] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [81988] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1301), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2310), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1655), 2, sym_comment, sym_include, - ACTIONS(1236), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63046] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82035] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1302), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2312), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1656), 2, sym_comment, sym_include, - ACTIONS(1616), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63086] = 5, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82082] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1303), 2, - sym_comment, - sym_include, - ACTIONS(1620), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2316), 1, + anon_sym_COLON, + ACTIONS(2318), 1, + aux_sym__while_condition_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63126] = 5, - ACTIONS(3), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + STATE(1888), 1, + aux_sym_do_block_repeat1, + STATE(1913), 1, + sym_to_phrase, + STATE(2269), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(3731), 1, + sym__while_condition, + STATE(1657), 2, + sym_comment, + sym_include, + STATE(3735), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [82137] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1304), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2326), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1658), 2, sym_comment, sym_include, - ACTIONS(1624), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63166] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82184] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1305), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2328), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1659), 2, sym_comment, sym_include, - ACTIONS(1652), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63206] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82231] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1306), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2330), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1660), 2, sym_comment, sym_include, - ACTIONS(1664), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63246] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82278] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1307), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2332), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1661), 2, sym_comment, sym_include, - ACTIONS(1664), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63286] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82325] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1308), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2215), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2217), 1, + aux_sym_variable_definition_token2, + ACTIONS(2219), 1, + aux_sym_property_definition_token2, + STATE(1730), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1662), 2, sym_comment, sym_include, - ACTIONS(1672), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63326] = 5, - ACTIONS(3), 1, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2213), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [82374] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1309), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2336), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2338), 1, + aux_sym_variable_definition_token2, + ACTIONS(2340), 1, + aux_sym_property_definition_token2, + STATE(1717), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1663), 2, sym_comment, sym_include, - ACTIONS(1684), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2334), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63366] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [82423] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1310), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2342), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1664), 2, sym_comment, sym_include, - ACTIONS(1688), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63406] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82470] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1311), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2233), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2235), 1, + aux_sym_variable_definition_token2, + ACTIONS(2237), 1, + aux_sym_property_definition_token2, + STATE(1745), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1665), 2, sym_comment, sym_include, - ACTIONS(1692), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2231), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63446] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [82519] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1312), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2344), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1666), 2, sym_comment, sym_include, - ACTIONS(1700), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63486] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82566] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1313), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2346), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1667), 2, sym_comment, sym_include, - ACTIONS(1704), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63526] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82613] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1314), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2350), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2352), 1, + aux_sym_variable_definition_token2, + ACTIONS(2354), 1, + aux_sym_property_definition_token2, + STATE(1763), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1668), 2, sym_comment, sym_include, - ACTIONS(1712), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2348), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63566] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [82662] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1315), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2356), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1669), 2, sym_comment, sym_include, - ACTIONS(1716), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63606] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82709] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1316), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2358), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1670), 2, sym_comment, sym_include, - ACTIONS(1232), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63646] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82756] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1317), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2360), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1671), 2, sym_comment, sym_include, - ACTIONS(1228), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63686] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82803] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1318), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2362), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1672), 2, sym_comment, sym_include, - ACTIONS(1228), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63726] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82850] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1319), 2, + ACTIONS(2364), 1, + anon_sym_RPAREN, + ACTIONS(2366), 1, + aux_sym_where_clause_token1, + ACTIONS(2372), 1, + aux_sym_query_tuning_token6, + ACTIONS(2375), 1, + aux_sym_of_token1, + ACTIONS(2378), 1, + aux_sym__using_first_token1, + STATE(1743), 1, + sym__using_first, + STATE(1673), 3, sym_comment, sym_include, - ACTIONS(1228), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63766] = 5, - ACTIONS(3), 1, + aux_sym_can_find_expression_repeat2, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(2369), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82895] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2381), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1674), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [82942] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1320), 2, + ACTIONS(2385), 1, + aux_sym_variable_definition_token4, + STATE(1675), 2, sym_comment, sym_include, - ACTIONS(1228), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63806] = 5, - ACTIONS(3), 1, + ACTIONS(2383), 14, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token1, + aux_sym_buffer_definition_token3, + aux_sym_query_definition_token1, + aux_sym_function_parameter_token1, + [82975] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1321), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2387), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1676), 2, sym_comment, sym_include, - ACTIONS(1740), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63846] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83022] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1322), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2389), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1677), 2, sym_comment, sym_include, - ACTIONS(1600), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63886] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83069] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1323), 2, + ACTIONS(2201), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2203), 1, + aux_sym_variable_definition_token2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2209), 1, + aux_sym_property_definition_token2, + STATE(1759), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1678), 2, sym_comment, sym_include, - ACTIONS(1340), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2199), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63926] = 6, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [83118] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1926), 1, - ts_builtin_sym_end, - STATE(1324), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2391), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1679), 2, sym_comment, sym_include, - ACTIONS(1928), 23, - sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [63968] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83165] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1325), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2393), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1680), 2, sym_comment, sym_include, - ACTIONS(1336), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64008] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83212] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1326), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2395), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1681), 2, sym_comment, sym_include, - ACTIONS(1574), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64048] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83259] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1327), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2397), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1682), 2, sym_comment, sym_include, - ACTIONS(1744), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64088] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83306] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1328), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2399), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1683), 2, sym_comment, sym_include, - ACTIONS(1748), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64128] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83353] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1329), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2401), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1684), 2, sym_comment, sym_include, - ACTIONS(1752), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64168] = 5, - ACTIONS(3), 1, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83400] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(996), 1, + aux_sym__using_first_token1, + ACTIONS(2403), 1, + anon_sym_RPAREN, + STATE(1673), 1, + aux_sym_can_find_expression_repeat2, + STATE(1743), 1, + sym__using_first, + STATE(1685), 2, + sym_comment, + sym_include, + STATE(1907), 3, + sym_where_clause, + sym_query_tuning, + sym_of, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [83447] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1330), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2407), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2409), 1, + aux_sym_variable_definition_token2, + ACTIONS(2411), 1, + aux_sym_property_definition_token2, + STATE(1736), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1686), 2, sym_comment, sym_include, - ACTIONS(1756), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2405), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64208] = 5, + aux_sym_method_definition_token1, + [83496] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1331), 2, - sym_comment, - sym_include, - ACTIONS(1760), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2318), 1, + aux_sym__while_condition_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64248] = 5, - ACTIONS(3), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2413), 1, + anon_sym_COLON, + STATE(1903), 1, + sym_to_phrase, + STATE(1917), 1, + aux_sym_do_block_repeat1, + STATE(2276), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3670), 1, + sym__while_condition, + STATE(3729), 1, + sym_assignment, + STATE(1687), 2, + sym_comment, + sym_include, + STATE(3678), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [83551] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1332), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2241), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2243), 1, + aux_sym_variable_definition_token2, + ACTIONS(2245), 1, + aux_sym_property_definition_token2, + STATE(1723), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1688), 2, sym_comment, sym_include, - ACTIONS(1764), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2239), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64288] = 5, + aux_sym_method_definition_token1, + [83600] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1333), 2, - sym_comment, - sym_include, - ACTIONS(1768), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2318), 1, + aux_sym__while_condition_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64328] = 6, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2415), 1, + anon_sym_COLON, + STATE(1909), 1, + aux_sym_do_block_repeat1, + STATE(1910), 1, + sym_to_phrase, + STATE(2273), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3716), 1, + sym__while_condition, + STATE(3729), 1, + sym_assignment, + STATE(1689), 2, + sym_comment, + sym_include, + STATE(3714), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [83655] = 17, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1930), 1, - ts_builtin_sym_end, - STATE(1334), 2, - sym_comment, - sym_include, - ACTIONS(1896), 23, + ACTIONS(2314), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2318), 1, + aux_sym__while_condition_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64370] = 5, - ACTIONS(3), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2417), 1, + anon_sym_COLON, + STATE(1894), 1, + aux_sym_do_block_repeat1, + STATE(1912), 1, + sym_to_phrase, + STATE(2238), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3462), 1, + sym__while_condition, + STATE(3729), 1, + sym_assignment, + STATE(1690), 2, + sym_comment, + sym_include, + STATE(3434), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [83710] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1335), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2407), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2409), 1, + aux_sym_variable_definition_token2, + STATE(1736), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1691), 2, sym_comment, sym_include, - ACTIONS(1772), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2405), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64410] = 5, + aux_sym_method_definition_token1, + [83756] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2090), 1, + aux_sym_buffer_definition_token3, + STATE(1695), 1, + aux_sym_variable_definition_repeat1, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1692), 2, + sym_comment, + sym_include, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1792), 3, + sym_scope_tuning, + sym_access_tuning, + sym_serialization_tuning, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [83796] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1336), 2, + ACTIONS(2421), 1, + anon_sym_LPAREN, + ACTIONS(2425), 1, + sym__namedot, + STATE(1796), 1, + aux_sym_qualified_name_repeat1, + STATE(2197), 1, + sym_sort_order, + STATE(1693), 2, sym_comment, sym_include, - ACTIONS(1884), 24, + ACTIONS(2423), 4, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + ACTIONS(2419), 6, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64450] = 5, - ACTIONS(3), 1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [83836] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1337), 2, + ACTIONS(2432), 1, + aux_sym_query_tuning_token6, + STATE(1795), 1, + sym_query_tuning, + STATE(1694), 3, sym_comment, sym_include, - ACTIONS(1224), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + aux_sym_for_phrase_repeat1, + ACTIONS(2429), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + ACTIONS(2427), 6, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64490] = 5, - ACTIONS(3), 1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [83872] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1338), 2, + ACTIONS(2435), 1, + aux_sym_buffer_definition_token3, + STATE(1643), 1, + aux_sym_variable_definition_repeat1, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + STATE(1695), 2, sym_comment, sym_include, - ACTIONS(1570), 24, - sym_identifier, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1792), 3, + sym_scope_tuning, + sym_access_tuning, + sym_serialization_tuning, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [83912] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + ACTIONS(2437), 1, + anon_sym_COLON, + STATE(1705), 1, + aux_sym_class_statement_repeat1, + STATE(1696), 2, + sym_comment, + sym_include, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [83958] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2441), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2443), 1, + aux_sym_variable_definition_token2, + STATE(1742), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1697), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2439), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64530] = 6, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84004] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1932), 1, - ts_builtin_sym_end, - STATE(1339), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2447), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2449), 1, + aux_sym_variable_definition_token2, + STATE(1724), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1698), 2, sym_comment, sym_include, - ACTIONS(1898), 23, - sym_identifier, - aux_sym_input_expression_token1, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2445), 3, + aux_sym__block_terminator_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64572] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84050] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1340), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2453), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2455), 1, + aux_sym_variable_definition_token2, + STATE(1755), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1699), 2, sym_comment, sym_include, - ACTIONS(1220), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2451), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64612] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84096] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1341), 2, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2276), 1, + anon_sym_COLON, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + STATE(1696), 1, + aux_sym_class_statement_repeat1, + STATE(1700), 2, + sym_comment, + sym_include, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [84142] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2459), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2461), 1, + aux_sym_variable_definition_token2, + STATE(1749), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1701), 2, sym_comment, sym_include, - ACTIONS(1220), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2457), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64652] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84188] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1342), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2272), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1783), 1, + sym_of, + STATE(1885), 1, + sym__pre_tuning, + STATE(2008), 1, + aux_sym_for_phrase_repeat1, + STATE(2009), 1, + sym_where_clause, + STATE(1702), 2, sym_comment, sym_include, - ACTIONS(1220), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64692] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [84236] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1343), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2465), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2467), 1, + aux_sym_variable_definition_token2, + STATE(1737), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1703), 2, sym_comment, sym_include, - ACTIONS(1220), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2463), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64732] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84282] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1344), 2, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + ACTIONS(2298), 1, + anon_sym_COLON, + STATE(1709), 1, + aux_sym_class_statement_repeat1, + STATE(1704), 2, sym_comment, sym_include, - ACTIONS(1286), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64772] = 5, - ACTIONS(3), 1, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [84328] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1345), 2, + ACTIONS(2469), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2472), 1, + anon_sym_COLON, + ACTIONS(2474), 1, + aux_sym_property_tuning_token1, + ACTIONS(2477), 1, + aux_sym_inherits_token1, + ACTIONS(2480), 1, + aux_sym_implements_token1, + ACTIONS(2483), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2486), 1, + aux_sym_final_token1, + STATE(1705), 3, sym_comment, sym_include, - ACTIONS(1798), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64812] = 5, - ACTIONS(3), 1, + aux_sym_class_statement_repeat1, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [84372] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1346), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2288), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1772), 1, + sym_of, + STATE(1840), 1, + sym__pre_tuning, + STATE(1956), 1, + aux_sym_for_phrase_repeat1, + STATE(1991), 1, + sym_where_clause, + STATE(1706), 2, sym_comment, sym_include, - ACTIONS(1802), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64852] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [84420] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1347), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2247), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1787), 1, + sym_of, + STATE(1798), 1, + sym__pre_tuning, + STATE(1987), 1, + sym_where_clause, + STATE(1996), 1, + aux_sym_for_phrase_repeat1, + STATE(1707), 2, sym_comment, sym_include, - ACTIONS(1816), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64892] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [84468] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1348), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2491), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2493), 1, + aux_sym_variable_definition_token2, + STATE(1751), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1708), 2, sym_comment, sym_include, - ACTIONS(1816), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2489), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64932] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84514] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1349), 2, + ACTIONS(2274), 1, + aux_sym_serialization_tuning_token1, + ACTIONS(2278), 1, + aux_sym_property_tuning_token1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(2282), 1, + aux_sym_implements_token1, + ACTIONS(2284), 1, + aux_sym_use_widget_pool_token1, + ACTIONS(2286), 1, + aux_sym_final_token1, + ACTIONS(2495), 1, + anon_sym_COLON, + STATE(1705), 1, + aux_sym_class_statement_repeat1, + STATE(1709), 2, sym_comment, sym_include, - ACTIONS(1816), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [64972] = 5, - ACTIONS(3), 1, + STATE(2067), 6, + sym_inherits, + sym_implements, + sym_use_widget_pool, + sym_abstract, + sym_final, + sym_serializable, + [84560] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1350), 2, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(994), 1, + aux_sym_of_token1, + ACTIONS(2296), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1789), 1, + sym_of, + STATE(1865), 1, + sym__pre_tuning, + STATE(1994), 1, + sym_where_clause, + STATE(1998), 1, + aux_sym_for_phrase_repeat1, + STATE(1710), 2, sym_comment, sym_include, - ACTIONS(1816), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65012] = 5, - ACTIONS(3), 1, + ACTIONS(990), 5, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + [84608] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1351), 2, + ACTIONS(2500), 1, + aux_sym_variable_definition_token4, + ACTIONS(2502), 2, + aux_sym_buffer_definition_token1, + aux_sym_query_definition_token1, + STATE(1711), 2, sym_comment, sym_include, - ACTIONS(1828), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65052] = 5, - ACTIONS(3), 1, + ACTIONS(2188), 4, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token3, + ACTIONS(2497), 7, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + [84644] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1352), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2350), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2352), 1, + aux_sym_variable_definition_token2, + STATE(1763), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1712), 2, sym_comment, sym_include, - ACTIONS(1848), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2348), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65092] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84690] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1353), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2506), 1, + aux_sym_variable_definition_token2, + STATE(1714), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1713), 2, sym_comment, sym_include, - ACTIONS(1852), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2504), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65132] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84733] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1354), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2443), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1714), 2, sym_comment, sym_include, - ACTIONS(1856), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2439), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65172] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84776] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1355), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2409), 1, + aux_sym_variable_definition_token2, + STATE(1736), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1715), 2, sym_comment, sym_include, - ACTIONS(1860), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2405), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65212] = 5, + aux_sym_method_definition_token1, + [84819] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1356), 2, + ACTIONS(2314), 1, + sym_identifier, + ACTIONS(2320), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2417), 1, + anon_sym_COLON, + STATE(1894), 1, + aux_sym_do_block_repeat1, + STATE(1912), 1, + sym_to_phrase, + STATE(2238), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1716), 2, sym_comment, sym_include, - ACTIONS(1290), 24, - sym_identifier, + STATE(3434), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [84868] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2352), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1717), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2348), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65252] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [84911] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1357), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2338), 1, + aux_sym_variable_definition_token2, + STATE(1717), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1718), 2, sym_comment, sym_include, - ACTIONS(1294), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2334), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [84954] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2513), 1, aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2515), 1, + aux_sym_getter_token1, + ACTIONS(2518), 1, + aux_sym_setter_token1, + STATE(3184), 1, + sym_access_tuning, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2508), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + ACTIONS(2510), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1719), 3, + sym_comment, + sym_include, + aux_sym_property_definition_repeat2, + [84995] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1720), 2, + sym_comment, + sym_include, + ACTIONS(2521), 13, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65292] = 5, - ACTIONS(3), 1, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [85024] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1358), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2525), 1, + aux_sym_variable_definition_token2, + STATE(1744), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1721), 2, sym_comment, sym_include, - ACTIONS(1566), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2523), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65332] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85067] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1359), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2529), 1, + aux_sym_variable_tuning_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1835), 1, + aux_sym_field_definition_repeat1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2533), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + STATE(1722), 2, sym_comment, sym_include, - ACTIONS(1294), 24, - sym_identifier, + ACTIONS(2527), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + ACTIONS(2531), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + [85110] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2525), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1723), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2523), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65372] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85153] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1360), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2537), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1724), 2, sym_comment, sym_include, - ACTIONS(1294), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2535), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65412] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85196] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1361), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2537), 1, + aux_sym_variable_definition_token2, + STATE(1738), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1725), 2, sym_comment, sym_include, - ACTIONS(1294), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2535), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65452] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85239] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1362), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2467), 1, + aux_sym_variable_definition_token2, + STATE(1737), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1726), 2, sym_comment, sym_include, - ACTIONS(1294), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2463), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65492] = 6, + aux_sym_method_definition_token1, + [85282] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1934), 1, - ts_builtin_sym_end, - STATE(1363), 2, - sym_comment, - sym_include, - ACTIONS(1936), 23, + ACTIONS(2314), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65534] = 5, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2539), 1, + anon_sym_COLON, + STATE(1918), 1, + aux_sym_do_block_repeat1, + STATE(1919), 1, + sym_to_phrase, + STATE(2349), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1727), 2, + sym_comment, + sym_include, + STATE(3484), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85331] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2543), 1, + aux_sym__using_and_token1, + STATE(1766), 1, + aux_sym_can_find_expression_repeat1, + STATE(1878), 1, + sym__using_and, + STATE(1728), 2, + sym_comment, + sym_include, + ACTIONS(2541), 10, + anon_sym_RPAREN, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [85366] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1364), 2, + ACTIONS(2314), 1, + sym_identifier, + ACTIONS(2320), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2545), 1, + anon_sym_COLON, + STATE(1889), 1, + sym_to_phrase, + STATE(1891), 1, + aux_sym_do_block_repeat1, + STATE(2323), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1729), 2, sym_comment, sym_include, - ACTIONS(1880), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, + STATE(3411), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85415] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2549), 1, aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65574] = 5, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1730), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2547), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [85458] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1365), 2, - sym_comment, - sym_include, - ACTIONS(1936), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65614] = 5, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2551), 1, + anon_sym_COLON, + STATE(1930), 1, + aux_sym_do_block_repeat1, + STATE(1931), 1, + sym_to_phrase, + STATE(2277), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1731), 2, + sym_comment, + sym_include, + STATE(3529), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85507] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1366), 2, - sym_comment, - sym_include, - ACTIONS(1928), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65654] = 5, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2553), 1, + anon_sym_COLON, + STATE(1925), 1, + sym_to_phrase, + STATE(1926), 1, + aux_sym_do_block_repeat1, + STATE(2272), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1732), 2, + sym_comment, + sym_include, + STATE(3546), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85556] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1367), 2, - sym_comment, - sym_include, - ACTIONS(1924), 24, + ACTIONS(2314), 1, sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2316), 1, + anon_sym_COLON, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65694] = 5, - ACTIONS(3), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + STATE(1888), 1, + aux_sym_do_block_repeat1, + STATE(1913), 1, + sym_to_phrase, + STATE(2269), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1733), 2, + sym_comment, + sym_include, + STATE(3735), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85605] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1368), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2338), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1734), 2, sym_comment, sym_include, - ACTIONS(1920), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2334), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65734] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85648] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1369), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2557), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1735), 2, sym_comment, sym_include, - ACTIONS(1914), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2555), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65774] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85691] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1370), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2467), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1736), 2, sym_comment, sym_include, - ACTIONS(1910), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2463), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65814] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85734] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1371), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2461), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1737), 2, sym_comment, sym_include, - ACTIONS(1298), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2457), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65854] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85777] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1372), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2561), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1738), 2, sym_comment, sym_include, - ACTIONS(1302), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2559), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [65894] = 24, - ACTIONS(373), 1, + aux_sym_method_definition_token1, + [85820] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1212), 1, - anon_sym_COLON, - STATE(1402), 1, - sym_of, - STATE(1427), 1, - sym__pre_tuning, - STATE(1449), 1, - sym_where_clause, - STATE(1455), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1633), 1, - aux_sym_for_phrase_repeat2, - STATE(1918), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1978), 1, - sym_on_quit_phrase, - STATE(2180), 1, - sym_on_stop_phrase, - STATE(2194), 1, - aux_sym_for_statement_repeat1, - STATE(1373), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2461), 1, + aux_sym_variable_definition_token2, + STATE(1749), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1739), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [65972] = 6, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2457), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [85863] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1938), 1, - ts_builtin_sym_end, - STATE(1374), 2, - sym_comment, - sym_include, - ACTIONS(1900), 23, + ACTIONS(2314), 1, sym_identifier, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66014] = 5, - ACTIONS(3), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2563), 1, + anon_sym_COLON, + STATE(1938), 1, + sym_to_phrase, + STATE(1941), 1, + aux_sym_do_block_repeat1, + STATE(2330), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1740), 2, + sym_comment, + sym_include, + STATE(3403), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [85912] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1375), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2567), 1, + aux_sym_variable_definition_token2, + STATE(1750), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1741), 2, sym_comment, sym_include, - ACTIONS(1868), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2565), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66054] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85955] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1376), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2567), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1742), 2, sym_comment, sym_include, - ACTIONS(1864), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2565), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66094] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [85998] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1377), 2, + ACTIONS(2543), 1, + aux_sym__using_and_token1, + STATE(1728), 1, + aux_sym_can_find_expression_repeat1, + STATE(1878), 1, + sym__using_and, + STATE(1743), 2, sym_comment, sym_include, - ACTIONS(1550), 24, - sym_identifier, + ACTIONS(2569), 10, + anon_sym_RPAREN, + aux_sym_where_clause_token1, + aux_sym_query_tuning_token1, + aux_sym_query_tuning_token2, + aux_sym_query_tuning_token3, + aux_sym_query_tuning_token4, + aux_sym_query_tuning_token5, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [86033] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2455), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1744), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2451), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [86076] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2506), 1, aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66134] = 5, - ACTIONS(3), 1, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1745), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2504), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [86119] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1378), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2449), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1746), 2, sym_comment, sym_include, - ACTIONS(1844), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2445), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66174] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86162] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1379), 2, + ACTIONS(2573), 1, + aux_sym_variable_definition_token4, + STATE(1747), 2, sym_comment, sym_include, - ACTIONS(1844), 24, - sym_identifier, - aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, - aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66214] = 5, - ACTIONS(3), 1, + ACTIONS(2571), 12, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token3, + aux_sym_property_definition_token1, + [86193] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1380), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2577), 1, + aux_sym_variable_definition_token2, + STATE(1756), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1748), 2, sym_comment, sym_include, - ACTIONS(1832), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2575), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66254] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86236] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1381), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2581), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1749), 2, sym_comment, sym_include, - ACTIONS(1824), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2579), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66294] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86279] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1382), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2585), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1750), 2, sym_comment, sym_include, - ACTIONS(1810), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2583), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66334] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86322] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1383), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2589), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1751), 2, sym_comment, sym_include, - ACTIONS(1794), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2587), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66374] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86365] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1384), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2581), 1, + aux_sym_variable_definition_token2, + STATE(1760), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1752), 2, sym_comment, sym_include, - ACTIONS(1320), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2579), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66414] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86408] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1385), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2593), 1, + aux_sym_variable_definition_token2, + STATE(1761), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1753), 2, sym_comment, sym_include, - ACTIONS(1324), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2591), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66454] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86451] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1386), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2589), 1, + aux_sym_variable_definition_token2, + STATE(1735), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1754), 2, sym_comment, sym_include, - ACTIONS(1324), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2587), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66494] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86494] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1387), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2593), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1755), 2, sym_comment, sym_include, - ACTIONS(1324), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2591), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66534] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86537] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1388), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2493), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1756), 2, sym_comment, sym_include, - ACTIONS(1324), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2489), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66574] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86580] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1389), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2549), 1, + aux_sym_variable_definition_token2, + STATE(1746), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1757), 2, sym_comment, sym_include, - ACTIONS(1328), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2547), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66614] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86623] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(61), 1, + aux_sym_variable_definition_token2, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1390), 2, + ACTIONS(2211), 1, + sym__namedot, + STATE(1764), 1, + aux_sym_qualified_name_repeat1, + STATE(1758), 2, sym_comment, sym_include, - ACTIONS(1448), 24, - sym_identifier, + ACTIONS(65), 10, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66654] = 5, - ACTIONS(3), 1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_property_definition_token2, + aux_sym_method_definition_token1, + [86658] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1391), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2577), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1759), 2, sym_comment, sym_include, - ACTIONS(1486), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2575), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [86701] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2597), 1, aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66694] = 5, - ACTIONS(3), 1, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1760), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2595), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [86744] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1392), 2, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2601), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1761), 2, sym_comment, sym_include, - ACTIONS(1490), 24, - sym_identifier, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2599), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66734] = 5, + aux_sym_method_definition_token1, + [86787] = 15, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1393), 2, + ACTIONS(2314), 1, + sym_identifier, + ACTIONS(2320), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2415), 1, + anon_sym_COLON, + STATE(1909), 1, + aux_sym_do_block_repeat1, + STATE(1910), 1, + sym_to_phrase, + STATE(2273), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1762), 2, sym_comment, sym_include, - ACTIONS(1494), 24, - sym_identifier, + STATE(3714), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [86836] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2409), 1, + aux_sym_variable_definition_token2, + STATE(1719), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1763), 2, + sym_comment, + sym_include, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2405), 3, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66774] = 5, - ACTIONS(3), 1, + aux_sym_method_definition_token1, + [86879] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1394), 2, + ACTIONS(69), 1, + aux_sym_variable_definition_token2, + ACTIONS(2603), 1, + sym__namedot, + STATE(1764), 3, sym_comment, sym_include, - ACTIONS(1332), 24, - sym_identifier, + aux_sym_qualified_name_repeat1, + ACTIONS(71), 10, aux_sym__block_terminator_token1, - aux_sym_input_expression_token1, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, aux_sym_variable_definition_token1, - aux_sym_variable_definition_token2, - aux_sym_buffer_definition_token2, - aux_sym_argument_mode_token1, - aux_sym_if_statement_token1, - aux_sym_repeat_statement_token1, - aux_sym_do_while_statement_token1, - aux_sym__procedure_terminator_token1, - aux_sym_procedure_parameter_definition_token1, - aux_sym__function_terminator_token1, - aux_sym_class_statement_token1, - aux_sym_on_error_phrase_token1, - aux_sym_on_error_phrase_token3, - aux_sym__case_terminator_token1, - aux_sym_find_statement_token1, - aux_sym_assign_statement_token1, - aux_sym_catch_statement_token1, - aux_sym_finally_statement_token1, - aux_sym_accumulate_statement_token1, - anon_sym_ROUTINE_DASHLEVEL, - anon_sym_BLOCK_DASHLEVEL, - [66814] = 22, - ACTIONS(373), 1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_property_definition_token2, + aux_sym_method_definition_token1, + [86912] = 15, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(1190), 1, + ACTIONS(2314), 1, + sym_identifier, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1412), 1, - sym_of, - STATE(1433), 1, - sym__pre_tuning, - STATE(1523), 1, - aux_sym_for_phrase_repeat1, - STATE(1526), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1693), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2048), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2413), 1, + anon_sym_COLON, + STATE(1903), 1, + sym_to_phrase, + STATE(1917), 1, + aux_sym_do_block_repeat1, + STATE(2276), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1765), 2, + sym_comment, + sym_include, + STATE(3678), 3, sym_on_error_phrase, - STATE(2084), 1, - sym_on_quit_phrase, - STATE(2902), 1, sym_on_stop_phrase, - ACTIONS(1422), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1395), 2, + sym_on_quit_phrase, + [86961] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2608), 1, + aux_sym__using_and_token1, + STATE(1878), 1, + sym__using_and, + STATE(1766), 3, sym_comment, sym_include, - ACTIONS(932), 5, + aux_sym_can_find_expression_repeat1, + ACTIONS(2606), 10, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [66887] = 22, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [86994] = 15, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2314), 1, + sym_identifier, + ACTIONS(2320), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1940), 1, + ACTIONS(2322), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2324), 1, + aux_sym_do_tuning_token1, + ACTIONS(2611), 1, anon_sym_COLON, - STATE(1426), 1, - sym__pre_tuning, - STATE(1471), 1, - sym_where_clause, - STATE(1481), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1626), 1, - aux_sym_for_phrase_repeat2, - STATE(1921), 1, + STATE(1887), 1, + sym_to_phrase, + STATE(1905), 1, + aux_sym_do_block_repeat1, + STATE(2342), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(3729), 1, + sym_assignment, + STATE(1767), 2, + sym_comment, + sym_include, + STATE(3494), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1990), 1, - sym_on_quit_phrase, - STATE(2209), 1, sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1396), 2, + sym_on_quit_phrase, + [87043] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2205), 1, + aux_sym_getter_token1, + ACTIONS(2207), 1, + aux_sym_setter_token1, + ACTIONS(2352), 1, + aux_sym_variable_definition_token2, + STATE(1763), 1, + aux_sym_property_definition_repeat2, + STATE(3184), 1, + sym_access_tuning, + STATE(1768), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [66959] = 4, - ACTIONS(3), 1, + STATE(2011), 2, + sym_getter, + sym_setter, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2348), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [87086] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(1397), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2193), 1, + aux_sym_function_parameter_token1, + STATE(3500), 1, + sym_access_tuning, + STATE(1769), 2, sym_comment, sym_include, - ACTIONS(1942), 23, - anon_sym_LBRACE, - sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, + ACTIONS(2613), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2188), 7, aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [66995] = 22, - ACTIONS(373), 1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_buffer_definition_token3, + [87120] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1944), 1, - anon_sym_COLON, - STATE(1424), 1, - sym__pre_tuning, - STATE(1453), 1, - aux_sym_for_phrase_repeat1, - STATE(1460), 1, - sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1651), 1, - aux_sym_for_phrase_repeat2, - STATE(1939), 1, - sym_on_error_phrase, - STATE(1958), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2182), 1, - sym_on_stop_phrase, - STATE(2369), 1, - aux_sym_for_statement_repeat1, - STATE(1398), 2, + ACTIONS(2616), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2618), 1, + aux_sym_query_definition_token1, + STATE(1779), 1, + aux_sym_buffer_definition_repeat1, + STATE(1770), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67067] = 22, - ACTIONS(373), 1, + STATE(1960), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [87158] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1946), 1, - anon_sym_COLON, - STATE(1429), 1, - sym__pre_tuning, - STATE(1485), 1, - sym_where_clause, - STATE(1508), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1660), 1, - aux_sym_for_phrase_repeat2, - STATE(1841), 1, - sym_on_error_phrase, - STATE(1948), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, - sym_on_stop_phrase, - STATE(1399), 2, + ACTIONS(2620), 1, + sym__terminator, + ACTIONS(2624), 1, + aux_sym_variable_definition_token6, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + STATE(1793), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2158), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1771), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67139] = 22, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87204] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1948), 1, - anon_sym_COLON, - STATE(1416), 1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2632), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1886), 1, sym__pre_tuning, - STATE(1507), 1, + STATE(2002), 1, aux_sym_for_phrase_repeat1, - STATE(1509), 1, + STATE(2005), 1, sym_where_clause, - STATE(1575), 1, - sym_query_tuning, - STATE(1612), 1, - aux_sym_for_phrase_repeat2, - STATE(1839), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2075), 1, - sym_on_quit_phrase, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1400), 2, + STATE(1772), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [67211] = 4, - ACTIONS(3), 1, + [87246] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - STATE(1401), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2634), 1, + sym__terminator, + ACTIONS(2636), 1, + aux_sym_variable_definition_token6, + STATE(1781), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2186), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1773), 2, sym_comment, sym_include, - ACTIONS(1950), 23, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87292] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, anon_sym_LBRACE, - sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [67247] = 22, - ACTIONS(373), 1, + ACTIONS(69), 1, + aux_sym_variable_definition_token2, + STATE(1774), 2, + sym_comment, + sym_include, + ACTIONS(71), 11, + sym__namedot, + aux_sym__block_terminator_token1, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_property_definition_token2, + aux_sym_method_definition_token1, + [87322] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1952), 1, - anon_sym_COLON, - STATE(1415), 1, - sym__pre_tuning, - STATE(1447), 1, - sym_where_clause, - STATE(1486), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1673), 1, - aux_sym_for_phrase_repeat2, - STATE(1936), 1, - sym_on_error_phrase, - STATE(1956), 1, - sym_on_quit_phrase, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2638), 1, + sym__terminator, + ACTIONS(2640), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, - aux_sym_for_statement_repeat1, - STATE(1402), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2213), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1775), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67319] = 4, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87368] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(1403), 2, - sym_comment, - sym_include, - ACTIONS(1954), 23, + ACTIONS(7), 1, anon_sym_LBRACE, + ACTIONS(2642), 1, sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [67355] = 4, + STATE(1777), 1, + aux_sym_index_definition_repeat1, + STATE(2018), 1, + aux_sym_sort_clause_repeat1, + STATE(2218), 1, + sym_index_tuning, + STATE(2468), 1, + sym_sort_column, + ACTIONS(2646), 2, + aux_sym_variable_definition_token5, + aux_sym_index_tuning_token1, + STATE(1776), 2, + sym_comment, + sym_include, + STATE(1993), 2, + sym_qualified_name, + sym_function_call, + ACTIONS(2644), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [87410] = 12, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(1404), 2, - sym_comment, - sym_include, - ACTIONS(1956), 23, + ACTIONS(7), 1, anon_sym_LBRACE, + ACTIONS(2642), 1, sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [67391] = 4, + STATE(2030), 1, + aux_sym_sort_clause_repeat1, + STATE(2032), 1, + aux_sym_index_definition_repeat1, + STATE(2218), 1, + sym_index_tuning, + STATE(2468), 1, + sym_sort_column, + ACTIONS(2646), 2, + aux_sym_variable_definition_token5, + aux_sym_index_tuning_token1, + STATE(1777), 2, + sym_comment, + sym_include, + STATE(1993), 2, + sym_qualified_name, + sym_function_call, + ACTIONS(2648), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [87452] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - STATE(1405), 2, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(2650), 1, + anon_sym_LPAREN, + ACTIONS(2654), 1, + sym__namedot, + STATE(1928), 1, + aux_sym_qualified_name_repeat1, + STATE(2483), 1, + sym_sort_order, + STATE(1778), 2, sym_comment, sym_include, - ACTIONS(1958), 23, - anon_sym_LBRACE, + ACTIONS(2419), 4, sym_identifier, - sym_null_expression, - aux_sym_boolean_literal_token1, - aux_sym_boolean_literal_token2, - aux_sym_boolean_literal_token3, - aux_sym_boolean_literal_token4, - sym__integer_literal, - anon_sym_DQUOTE, - anon_sym_SQUOTE, - anon_sym_LPAREN, - aux_sym_unary_expression_token1, - aux_sym_unary_expression_token2, - aux_sym_ambiguous_expression_token1, - aux_sym_current_changed_expression_token1, - aux_sym_locked_expression_token1, - aux_sym_input_expression_token1, - aux_sym_scope_tuning_token1, - aux_sym_if_statement_token1, - aux_sym_can_find_expression_token1, - aux_sym_accumulate_expression_token1, - aux_sym_available_expression_token1, - aux_sym_available_expression_token2, - [67427] = 22, - ACTIONS(373), 1, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + ACTIONS(2652), 4, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + [87490] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1960), 1, - anon_sym_COLON, - STATE(1417), 1, - sym__pre_tuning, - STATE(1501), 1, - sym_where_clause, - STATE(1512), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1665), 1, - aux_sym_for_phrase_repeat2, - STATE(1895), 1, - sym_on_error_phrase, - STATE(1947), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, - sym_on_stop_phrase, - STATE(1406), 2, + ACTIONS(2662), 2, + aux_sym_buffer_definition_token1, + aux_sym_query_definition_token1, + STATE(1960), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2659), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + STATE(1779), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67499] = 22, - ACTIONS(373), 1, + aux_sym_buffer_definition_repeat1, + ACTIONS(2656), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [87524] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1962), 1, - anon_sym_COLON, - STATE(1425), 1, - sym__pre_tuning, - STATE(1465), 1, - sym_where_clause, - STATE(1477), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1617), 1, - aux_sym_for_phrase_repeat2, - STATE(1902), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2050), 1, - sym_on_quit_phrase, - STATE(2375), 1, - sym_on_stop_phrase, - STATE(2380), 1, - aux_sym_for_statement_repeat1, - STATE(1407), 2, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2664), 1, + sym__terminator, + ACTIONS(2666), 1, + aux_sym_variable_definition_token6, + STATE(1785), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2142), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1780), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67571] = 22, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87570] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1964), 1, - anon_sym_COLON, - STATE(1430), 1, - sym__pre_tuning, - STATE(1482), 1, - sym_where_clause, - STATE(1500), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1666), 1, - aux_sym_for_phrase_repeat2, - STATE(1881), 1, - sym_on_error_phrase, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2668), 1, + sym__terminator, + ACTIONS(2670), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2070), 1, - sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, - sym_on_stop_phrase, - STATE(1408), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2160), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1781), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67643] = 22, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87616] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1966), 1, - anon_sym_COLON, - STATE(1428), 1, - sym__pre_tuning, - STATE(1475), 1, - sym_where_clause, - STATE(1483), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1685), 1, - aux_sym_for_phrase_repeat2, - STATE(1942), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(1409), 2, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2668), 1, + sym__terminator, + ACTIONS(2670), 1, + aux_sym_variable_definition_token6, + STATE(1784), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2160), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1782), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67715] = 22, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87662] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1968), 1, - anon_sym_COLON, - STATE(1421), 1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2672), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1838), 1, sym__pre_tuning, - STATE(1479), 1, + STATE(1977), 1, sym_where_clause, - STATE(1489), 1, + STATE(1978), 1, aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1611), 1, - aux_sym_for_phrase_repeat2, - STATE(1941), 1, - sym_on_error_phrase, - STATE(1960), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, - sym_on_stop_phrase, - STATE(1410), 2, + STATE(1783), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [67787] = 21, - ACTIONS(373), 1, + [87704] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1966), 1, - anon_sym_COLON, - STATE(1475), 1, - sym_where_clause, - STATE(1483), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1685), 1, - aux_sym_for_phrase_repeat2, - STATE(1942), 1, - sym_on_error_phrase, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2674), 1, + sym__terminator, + ACTIONS(2676), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(1411), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2114), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1784), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67856] = 20, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87750] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1439), 1, - sym__pre_tuning, - STATE(1521), 1, - sym_where_clause, - STATE(1529), 1, - aux_sym_for_phrase_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1709), 1, - aux_sym_for_phrase_repeat2, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2678), 1, + sym__terminator, + ACTIONS(2680), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2013), 1, - sym_on_error_phrase, - STATE(2143), 1, - sym_on_quit_phrase, - STATE(2929), 1, - sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1412), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2153), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1785), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67923] = 21, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87796] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1968), 1, - anon_sym_COLON, - STATE(1479), 1, - sym_where_clause, - STATE(1489), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1611), 1, - aux_sym_for_phrase_repeat2, - STATE(1941), 1, - sym_on_error_phrase, - STATE(1960), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, - sym_on_stop_phrase, - STATE(1413), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [67992] = 21, - ACTIONS(373), 1, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2678), 1, + sym__terminator, + ACTIONS(2680), 1, + aux_sym_variable_definition_token6, + STATE(1791), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2153), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1786), 2, + sym_comment, + sym_include, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [87842] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1940), 1, - anon_sym_COLON, - STATE(1471), 1, - sym_where_clause, - STATE(1481), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2682), 1, + sym__terminator, + STATE(1720), 1, sym_query_tuning, - STATE(1626), 1, - aux_sym_for_phrase_repeat2, - STATE(1921), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1990), 1, - sym_on_quit_phrase, - STATE(2209), 1, - sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1414), 2, + STATE(1825), 1, + sym__pre_tuning, + STATE(1992), 1, + aux_sym_for_phrase_repeat1, + STATE(2004), 1, + sym_where_clause, + STATE(1787), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [68061] = 21, - ACTIONS(373), 1, + [87884] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1972), 1, - anon_sym_COLON, - STATE(1505), 1, - aux_sym_for_phrase_repeat1, - STATE(1506), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1663), 1, - aux_sym_for_phrase_repeat2, - STATE(1873), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2030), 1, - sym_on_quit_phrase, - STATE(2434), 1, - aux_sym_for_statement_repeat1, - STATE(2435), 1, - sym_on_stop_phrase, - STATE(1415), 2, + ACTIONS(2684), 1, + aux_sym_buffer_definition_token1, + ACTIONS(2686), 1, + aux_sym_query_definition_token1, + STATE(1779), 1, + aux_sym_buffer_definition_repeat1, + STATE(1788), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68130] = 21, - ACTIONS(373), 1, + STATE(1960), 2, + sym_scope_tuning, + sym_access_tuning, + ACTIONS(2006), 3, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + ACTIONS(2004), 4, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + [87922] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1974), 1, - anon_sym_COLON, - STATE(1448), 1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2688), 1, + sym__terminator, + STATE(1720), 1, + sym_query_tuning, + STATE(1830), 1, + sym__pre_tuning, + STATE(1969), 1, aux_sym_for_phrase_repeat1, - STATE(1511), 1, + STATE(1975), 1, sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1656), 1, - aux_sym_for_phrase_repeat2, - STATE(1860), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2051), 1, - sym_on_quit_phrase, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(1416), 2, + STATE(1789), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [68199] = 21, - ACTIONS(373), 1, + [87964] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2690), 1, + sym__namedot, + STATE(1790), 3, + sym_comment, + sym_include, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 10, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(1976), 1, - anon_sym_COLON, - STATE(1457), 1, - sym_where_clause, - STATE(1459), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1690), 1, - aux_sym_for_phrase_repeat2, - STATE(1898), 1, - sym_on_error_phrase, + [87994] = 14, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2693), 1, + sym__terminator, + ACTIONS(2695), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2065), 1, - sym_on_quit_phrase, - STATE(2336), 1, - sym_on_stop_phrase, - STATE(2342), 1, - aux_sym_for_statement_repeat1, - STATE(1417), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2165), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1791), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68268] = 21, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [88040] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1946), 1, - anon_sym_COLON, - STATE(1485), 1, - sym_where_clause, - STATE(1508), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1660), 1, - aux_sym_for_phrase_repeat2, - STATE(1841), 1, - sym_on_error_phrase, - STATE(1948), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, - sym_on_stop_phrase, - STATE(1418), 2, + ACTIONS(2500), 1, + aux_sym_variable_definition_token4, + STATE(1792), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68337] = 21, - ACTIONS(373), 1, + ACTIONS(2188), 11, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_variable_definition_token3, + aux_sym_buffer_definition_token3, + [88070] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1962), 1, - anon_sym_COLON, - STATE(1465), 1, - sym_where_clause, - STATE(1477), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1617), 1, - aux_sym_for_phrase_repeat2, - STATE(1902), 1, - sym_on_error_phrase, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2697), 1, + sym__terminator, + ACTIONS(2699), 1, + aux_sym_variable_definition_token6, STATE(1962), 1, - sym_sort_clause, - STATE(2050), 1, - sym_on_quit_phrase, - STATE(2375), 1, - sym_on_stop_phrase, - STATE(2380), 1, - aux_sym_for_statement_repeat1, - STATE(1419), 2, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2147), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1793), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68406] = 21, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [88116] = 14, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1964), 1, - anon_sym_COLON, - STATE(1482), 1, - sym_where_clause, - STATE(1500), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1666), 1, - aux_sym_for_phrase_repeat2, - STATE(1881), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2070), 1, - sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, - sym_on_stop_phrase, - STATE(1420), 2, + ACTIONS(2626), 1, + anon_sym_LIKE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2697), 1, + sym__terminator, + ACTIONS(2699), 1, + aux_sym_variable_definition_token6, + STATE(1775), 1, + aux_sym_temp_table_definition_repeat1, + STATE(2084), 1, + sym_temp_table_tuning, + STATE(2147), 1, + aux_sym_temp_table_definition_repeat2, + ACTIONS(2622), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1794), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68475] = 21, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [88162] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1978), 1, - anon_sym_COLON, - STATE(1463), 1, - aux_sym_for_phrase_repeat1, - STATE(1469), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1678), 1, - aux_sym_for_phrase_repeat2, - STATE(1904), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1998), 1, - sym_on_quit_phrase, - STATE(2391), 1, - sym_on_stop_phrase, - STATE(2392), 1, - aux_sym_for_statement_repeat1, - STATE(1421), 2, + STATE(1795), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2701), 12, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [68544] = 21, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [88190] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2425), 1, + sym__namedot, + STATE(1790), 1, + aux_sym_qualified_name_repeat1, + STATE(1796), 2, + sym_comment, + sym_include, + ACTIONS(61), 10, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(1960), 1, - anon_sym_COLON, - STATE(1501), 1, - sym_where_clause, - STATE(1512), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1665), 1, - aux_sym_for_phrase_repeat2, - STATE(1895), 1, - sym_on_error_phrase, - STATE(1947), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, - sym_on_stop_phrase, - STATE(1422), 2, + [88222] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(398), 1, + sym_accumulate_aggregate, + STATE(1797), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68613] = 21, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [88251] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, + ACTIONS(988), 1, aux_sym_where_clause_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1944), 1, - anon_sym_COLON, - STATE(1453), 1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2682), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1992), 1, aux_sym_for_phrase_repeat1, - STATE(1460), 1, + STATE(2004), 1, sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1651), 1, - aux_sym_for_phrase_repeat2, - STATE(1939), 1, - sym_on_error_phrase, - STATE(1958), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2182), 1, - sym_on_stop_phrase, - STATE(2369), 1, - aux_sym_for_statement_repeat1, - STATE(1423), 2, + STATE(1798), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [68682] = 21, - ACTIONS(373), 1, + [88290] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1980), 1, + ACTIONS(2056), 1, anon_sym_COLON, - STATE(1466), 1, - sym_where_clause, - STATE(1467), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1674), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1927), 1, + STATE(2183), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1971), 1, + STATE(2278), 1, sym_on_quit_phrase, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, + STATE(2636), 1, sym_on_stop_phrase, - STATE(1424), 2, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(1799), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68751] = 21, - ACTIONS(373), 1, + [88337] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(494), 1, + sym_accumulate_aggregate, + STATE(1800), 2, + sym_comment, + sym_include, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [88366] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1982), 1, + ACTIONS(2118), 1, anon_sym_COLON, - STATE(1478), 1, - sym_where_clause, - STATE(1492), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1659), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1892), 1, + STATE(2123), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2014), 1, + STATE(2292), 1, sym_on_quit_phrase, - STATE(2489), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 1, + STATE(2672), 1, sym_on_stop_phrase, - STATE(1425), 2, + STATE(2673), 1, + aux_sym_for_statement_repeat1, + STATE(1801), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68820] = 21, - ACTIONS(373), 1, + [88413] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2707), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1970), 1, + aux_sym_inherits_repeat1, + STATE(1802), 2, + sym_comment, + sym_include, + ACTIONS(2705), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [88448] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1984), 1, + ACTIONS(2160), 1, anon_sym_COLON, - STATE(1496), 1, - aux_sym_for_phrase_repeat1, - STATE(1499), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1667), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1840), 1, + STATE(2120), 1, sym_on_error_phrase, - STATE(1957), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2333), 1, + STATE(2288), 1, + sym_on_quit_phrase, + STATE(2664), 1, sym_on_stop_phrase, - STATE(2418), 1, + STATE(2665), 1, aux_sym_for_statement_repeat1, - STATE(1426), 2, + STATE(1803), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68889] = 21, - ACTIONS(373), 1, + [88495] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1952), 1, + ACTIONS(2709), 1, anon_sym_COLON, - STATE(1447), 1, - sym_where_clause, - STATE(1486), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1673), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1936), 1, + STATE(2143), 1, sym_on_error_phrase, - STATE(1956), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2249), 1, + STATE(2336), 1, + sym_on_quit_phrase, + STATE(2726), 1, sym_on_stop_phrase, - STATE(2268), 1, + STATE(2727), 1, aux_sym_for_statement_repeat1, - STATE(1427), 2, + STATE(1804), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [68958] = 21, - ACTIONS(373), 1, + [88542] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2711), 1, + aux_sym__block_terminator_token1, + ACTIONS(2713), 1, + aux_sym_variable_definition_token1, + ACTIONS(2715), 1, + aux_sym_variable_definition_token2, + ACTIONS(2717), 1, + aux_sym_method_definition_token1, + STATE(1906), 1, + aux_sym_interface_body_repeat1, + STATE(3493), 1, + sym_interface_body, + STATE(1805), 2, + sym_comment, + sym_include, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [88581] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1986), 1, + ACTIONS(2168), 1, anon_sym_COLON, - STATE(1451), 1, - sym_where_clause, - STATE(1468), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1680), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1861), 1, + STATE(2110), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1995), 1, + STATE(2287), 1, sym_on_quit_phrase, - STATE(2221), 1, - aux_sym_for_statement_repeat1, - STATE(2294), 1, + STATE(2662), 1, sym_on_stop_phrase, - STATE(1428), 2, + STATE(2663), 1, + aux_sym_for_statement_repeat1, + STATE(1806), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69027] = 21, - ACTIONS(373), 1, + [88628] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2707), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1966), 1, + aux_sym_inherits_repeat1, + STATE(1807), 2, + sym_comment, + sym_include, + ACTIONS(2719), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [88663] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1988), 1, + ACTIONS(2721), 1, anon_sym_COLON, - STATE(1510), 1, - aux_sym_for_phrase_repeat1, - STATE(1516), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1681), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1917), 1, + STATE(2101), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1983), 1, + STATE(2286), 1, sym_on_quit_phrase, - STATE(2210), 1, + STATE(2660), 1, sym_on_stop_phrase, - STATE(2231), 1, + STATE(2661), 1, aux_sym_for_statement_repeat1, - STATE(1429), 2, + STATE(1808), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69096] = 21, - ACTIONS(373), 1, + [88710] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1990), 1, + ACTIONS(2162), 1, anon_sym_COLON, - STATE(1456), 1, - aux_sym_for_phrase_repeat1, - STATE(1458), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1629), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1926), 1, + STATE(2140), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2001), 1, + STATE(2285), 1, sym_on_quit_phrase, - STATE(2237), 1, + STATE(2658), 1, sym_on_stop_phrase, - STATE(2276), 1, + STATE(2659), 1, aux_sym_for_statement_repeat1, - STATE(1430), 2, + STATE(1809), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69165] = 21, - ACTIONS(373), 1, + [88757] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1948), 1, + ACTIONS(2122), 1, anon_sym_COLON, - STATE(1507), 1, - aux_sym_for_phrase_repeat1, - STATE(1509), 1, - sym_where_clause, - STATE(1597), 1, - sym_query_tuning, - STATE(1612), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1839), 1, + STATE(2144), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2075), 1, + STATE(2339), 1, sym_on_quit_phrase, - STATE(2468), 1, + STATE(2730), 1, sym_on_stop_phrase, - STATE(2523), 1, + STATE(2731), 1, aux_sym_for_statement_repeat1, - STATE(1431), 2, + STATE(1810), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69234] = 8, - ACTIONS(3), 1, + [88804] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1768), 1, - sym_primitive_type, - STATE(1432), 2, + STATE(422), 1, + sym_accumulate_aggregate, + STATE(1811), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69276] = 19, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [88833] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1521), 1, - sym_where_clause, - STATE(1529), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1709), 1, + ACTIONS(2723), 1, + anon_sym_COLON, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2013), 1, + STATE(2104), 1, sym_on_error_phrase, - STATE(2143), 1, + STATE(2227), 1, + sym_sort_clause, + STATE(2282), 1, sym_on_quit_phrase, - STATE(2929), 1, + STATE(2653), 1, sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1433), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69340] = 8, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(3246), 1, - sym_primitive_type, - STATE(1434), 2, - sym_comment, - sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69382] = 8, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1749), 1, - sym_primitive_type, - STATE(1435), 2, + STATE(2654), 1, + aux_sym_for_statement_repeat1, + STATE(1812), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69424] = 8, - ACTIONS(3), 1, + [88880] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(3129), 1, - sym_primitive_type, - STATE(1436), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2725), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2151), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2340), 1, + sym_on_quit_phrase, + STATE(2732), 1, + sym_on_stop_phrase, + STATE(2734), 1, + aux_sym_for_statement_repeat1, + STATE(1813), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69466] = 8, - ACTIONS(3), 1, + [88927] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1721), 1, - sym_primitive_type, - STATE(1437), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2124), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2152), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2343), 1, + sym_on_quit_phrase, + STATE(2737), 1, + sym_on_stop_phrase, + STATE(2739), 1, + aux_sym_for_statement_repeat1, + STATE(1814), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69508] = 17, - ACTIONS(373), 1, + [88974] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1458), 1, - aux_sym_variable_definition_token3, - ACTIONS(1460), 1, - aux_sym_variable_definition_token4, - ACTIONS(1462), 1, - aux_sym_buffer_definition_token1, - ACTIONS(1464), 1, - aux_sym_buffer_definition_token3, - ACTIONS(1466), 1, - aux_sym_query_definition_token1, - ACTIONS(1470), 1, - aux_sym_stream_definition_token1, - STATE(1534), 1, - aux_sym_variable_definition_repeat1, - STATE(1604), 1, - aux_sym_buffer_definition_repeat1, - STATE(1605), 1, - sym_serialization_tuning, - ACTIONS(1456), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - STATE(1438), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2144), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2157), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2345), 1, + sym_on_quit_phrase, + STATE(2735), 1, + aux_sym_for_statement_repeat1, + STATE(2745), 1, + sym_on_stop_phrase, + STATE(1815), 2, sym_comment, sym_include, - STATE(1571), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, + [89021] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(422), 1, + aux_sym_variable_definition_token2, + ACTIONS(2727), 1, + sym__namedot, + STATE(1816), 2, + sym_comment, + sym_include, + ACTIONS(424), 9, + aux_sym__block_terminator_token1, + aux_sym_variable_tuning_token6, aux_sym_access_tuning_token1, aux_sym_access_tuning_token2, aux_sym_access_tuning_token3, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [69568] = 19, - ACTIONS(373), 1, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [89052] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1192), 1, - aux_sym_where_clause_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1525), 1, - sym_where_clause, - STATE(1527), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1697), 1, + ACTIONS(2126), 1, + anon_sym_COLON, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2041), 1, + STATE(2154), 1, sym_on_error_phrase, - STATE(2095), 1, + STATE(2227), 1, + sym_sort_clause, + STATE(2344), 1, sym_on_quit_phrase, - STATE(2966), 1, + STATE(2743), 1, sym_on_stop_phrase, - ACTIONS(1996), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1439), 2, + STATE(2744), 1, + aux_sym_for_statement_repeat1, + STATE(1817), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [69632] = 8, - ACTIONS(3), 1, + [89099] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(2936), 1, - sym_primitive_type, - STATE(1440), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2729), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2215), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2248), 1, + sym_on_quit_phrase, + STATE(2827), 1, + sym_on_stop_phrase, + STATE(2848), 1, + aux_sym_for_statement_repeat1, + STATE(1818), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69674] = 8, - ACTIONS(3), 1, + [89146] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1742), 1, - sym_primitive_type, - STATE(1441), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2114), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2156), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2347), 1, + sym_on_quit_phrase, + STATE(2747), 1, + sym_on_stop_phrase, + STATE(2749), 1, + aux_sym_for_statement_repeat1, + STATE(1819), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69716] = 8, - ACTIONS(3), 1, + [89193] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(2968), 1, - sym_primitive_type, - STATE(1442), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2124), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2295), 1, + sym_on_quit_phrase, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(1820), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69758] = 8, - ACTIONS(3), 1, + [89240] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1744), 1, - sym_primitive_type, - STATE(1443), 2, + ACTIONS(2529), 1, + aux_sym_variable_tuning_token1, + STATE(1828), 1, + aux_sym_field_definition_repeat1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2533), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + STATE(1821), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69800] = 8, - ACTIONS(3), 1, + ACTIONS(2531), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + ACTIONS(2731), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [89277] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1992), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1751), 1, - sym_primitive_type, - STATE(1444), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, + aux_sym_sort_clause_token1, + ACTIONS(1288), 1, + aux_sym_sort_clause_token2, + ACTIONS(2128), 1, + anon_sym_COLON, + STATE(2074), 1, + aux_sym_for_phrase_repeat2, + STATE(2159), 1, + sym_on_error_phrase, + STATE(2227), 1, + sym_sort_clause, + STATE(2348), 1, + sym_on_quit_phrase, + STATE(2751), 1, + sym_on_stop_phrase, + STATE(2752), 1, + aux_sym_for_statement_repeat1, + STATE(1822), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69842] = 8, - ACTIONS(3), 1, + [89324] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1998), 1, - sym_identifier, - STATE(1580), 1, - sym_qualified_name, - STATE(1623), 1, - sym_primitive_type, - STATE(1445), 2, + STATE(470), 1, + sym_accumulate_aggregate, + STATE(1823), 2, sym_comment, sym_include, - ACTIONS(1994), 17, - aux_sym_primitive_type_token1, - aux_sym_primitive_type_token2, - aux_sym_primitive_type_token3, - aux_sym_primitive_type_token4, - aux_sym_primitive_type_token5, - aux_sym_primitive_type_token6, - aux_sym_primitive_type_token7, - aux_sym_primitive_type_token8, - aux_sym_primitive_type_token9, - aux_sym_primitive_type_token10, - aux_sym_primitive_type_token11, - aux_sym_primitive_type_token12, - aux_sym_primitive_type_token13, - aux_sym_primitive_type_token14, - aux_sym_primitive_type_token15, - aux_sym_primitive_type_token16, - aux_sym_primitive_type_token17, - [69884] = 17, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [89353] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1636), 1, - aux_sym_variable_definition_token3, - ACTIONS(1638), 1, - aux_sym_variable_definition_token4, - ACTIONS(1640), 1, - aux_sym_buffer_definition_token1, - ACTIONS(1642), 1, - aux_sym_buffer_definition_token3, - ACTIONS(1644), 1, - aux_sym_query_definition_token1, - ACTIONS(1648), 1, - aux_sym_stream_definition_token1, - STATE(1539), 1, - aux_sym_variable_definition_repeat1, - STATE(1598), 1, - aux_sym_buffer_definition_repeat1, - STATE(1605), 1, - sym_serialization_tuning, - ACTIONS(1456), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - STATE(1446), 2, + STATE(442), 1, + sym_accumulate_aggregate, + STATE(1824), 2, sym_comment, sym_include, - STATE(1571), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [69944] = 19, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [89382] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1972), 1, - anon_sym_COLON, - STATE(1505), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2733), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1663), 1, - aux_sym_for_phrase_repeat2, - STATE(1873), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2030), 1, - sym_on_quit_phrase, - STATE(2434), 1, - aux_sym_for_statement_repeat1, - STATE(2435), 1, - sym_on_stop_phrase, - STATE(1447), 2, + STATE(2000), 1, + sym_where_clause, + STATE(2001), 1, + aux_sym_for_phrase_repeat1, + STATE(1825), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [70007] = 19, - ACTIONS(373), 1, + [89421] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2000), 1, + ACTIONS(2166), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1636), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1890), 1, + STATE(2210), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2021), 1, + STATE(2300), 1, sym_on_quit_phrase, - STATE(2419), 1, - sym_on_stop_phrase, - STATE(2420), 1, + STATE(2862), 1, aux_sym_for_statement_repeat1, - STATE(1448), 2, + STATE(2864), 1, + sym_on_stop_phrase, + STATE(1826), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70070] = 19, - ACTIONS(373), 1, + [89468] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1952), 1, + ACTIONS(2068), 1, anon_sym_COLON, - STATE(1486), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1673), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1936), 1, + STATE(2163), 1, sym_on_error_phrase, - STATE(1956), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, aux_sym_for_statement_repeat1, - STATE(1449), 2, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(1827), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70133] = 19, - ACTIONS(373), 1, + [89515] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(2737), 1, + aux_sym_variable_tuning_token1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2743), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + ACTIONS(2735), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + ACTIONS(2740), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + STATE(1828), 3, + sym_comment, + sym_include, + aux_sym_field_definition_repeat1, + [89550] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2856), 1, + sym_accumulate_aggregate, + STATE(1829), 2, + sym_comment, + sym_include, + ACTIONS(2746), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [89579] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1944), 1, - anon_sym_COLON, - STATE(1453), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2748), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1651), 1, - aux_sym_for_phrase_repeat2, - STATE(1939), 1, - sym_on_error_phrase, - STATE(1958), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2182), 1, - sym_on_stop_phrase, - STATE(2369), 1, - aux_sym_for_statement_repeat1, - STATE(1450), 2, + STATE(1989), 1, + aux_sym_for_phrase_repeat1, + STATE(1990), 1, + sym_where_clause, + STATE(1830), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [70196] = 19, - ACTIONS(373), 1, + [89618] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2002), 1, - anon_sym_COLON, - STATE(1464), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1634), 1, - aux_sym_for_phrase_repeat2, - STATE(1885), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2026), 1, - sym_on_quit_phrase, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2356), 1, - sym_on_stop_phrase, - STATE(1451), 2, + STATE(1831), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2750), 11, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [70259] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym__using_and_token1, + [89645] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2004), 1, + ACTIONS(2106), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1675), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1857), 1, + STATE(2131), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2060), 1, + STATE(2312), 1, sym_on_quit_phrase, - STATE(2321), 1, + STATE(2624), 1, aux_sym_for_statement_repeat1, - STATE(2337), 1, + STATE(2625), 1, sym_on_stop_phrase, - STATE(1452), 2, + STATE(1832), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70322] = 19, - ACTIONS(373), 1, + [89692] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1980), 1, + ACTIONS(2108), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1674), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1927), 1, + STATE(2164), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1971), 1, + STATE(2352), 1, sym_on_quit_phrase, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, + STATE(2759), 1, sym_on_stop_phrase, - STATE(1453), 2, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(1833), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70385] = 19, - ACTIONS(373), 1, + [89739] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(3091), 1, + sym_accumulate_aggregate, + STATE(1834), 2, + sym_comment, + sym_include, + ACTIONS(2746), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [89768] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2529), 1, + aux_sym_variable_tuning_token1, + STATE(1828), 1, + aux_sym_field_definition_repeat1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2533), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + STATE(1835), 2, + sym_comment, + sym_include, + ACTIONS(2531), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + ACTIONS(2752), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [89805] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2195), 1, + aux_sym_property_definition_token1, + STATE(1836), 2, + sym_comment, + sym_include, + ACTIONS(2188), 10, + aux_sym_scope_tuning_token1, + aux_sym_scope_tuning_token2, + aux_sym_scope_tuning_token3, + aux_sym_scope_tuning_token4, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_buffer_definition_token3, + [89834] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1944), 1, + ACTIONS(2050), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1651), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1939), 1, + STATE(2171), 1, sym_on_error_phrase, - STATE(1958), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2182), 1, - sym_on_stop_phrase, - STATE(2369), 1, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, aux_sym_for_statement_repeat1, - STATE(1454), 2, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(1837), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70448] = 19, - ACTIONS(373), 1, + [89881] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1952), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2754), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1673), 1, - aux_sym_for_phrase_repeat2, - STATE(1936), 1, - sym_on_error_phrase, - STATE(1956), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, - aux_sym_for_statement_repeat1, - STATE(1455), 2, + STATE(1947), 1, + aux_sym_for_phrase_repeat1, + STATE(1948), 1, + sym_where_clause, + STATE(1838), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [70511] = 19, - ACTIONS(373), 1, + [89920] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2006), 1, + ACTIONS(2060), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1670), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1900), 1, + STATE(2139), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1988), 1, + STATE(2263), 1, sym_on_quit_phrase, - STATE(2200), 1, - sym_on_stop_phrase, - STATE(2224), 1, + STATE(2618), 1, aux_sym_for_statement_repeat1, - STATE(1456), 2, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(1839), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70574] = 19, - ACTIONS(373), 1, + [89967] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2008), 1, - anon_sym_COLON, - STATE(1484), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2632), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1625), 1, - aux_sym_for_phrase_repeat2, - STATE(1863), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2055), 1, - sym_on_quit_phrase, - STATE(2308), 1, - sym_on_stop_phrase, - STATE(2310), 1, - aux_sym_for_statement_repeat1, - STATE(1457), 2, + STATE(2002), 1, + aux_sym_for_phrase_repeat1, + STATE(2005), 1, + sym_where_clause, + STATE(1840), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [70637] = 19, - ACTIONS(373), 1, + [90006] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(533), 1, + sym_accumulate_aggregate, + STATE(1841), 2, + sym_comment, + sym_include, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [90035] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2006), 1, + ACTIONS(2756), 1, anon_sym_COLON, - STATE(1498), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1670), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1900), 1, + STATE(2201), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1988), 1, + STATE(2240), 1, sym_on_quit_phrase, - STATE(2200), 1, + STATE(2558), 1, sym_on_stop_phrase, - STATE(2224), 1, + STATE(2560), 1, aux_sym_for_statement_repeat1, - STATE(1458), 2, + STATE(1842), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70700] = 19, - ACTIONS(373), 1, + [90082] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2008), 1, + ACTIONS(2130), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1625), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1863), 1, + STATE(2198), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2055), 1, + STATE(2243), 1, sym_on_quit_phrase, - STATE(2308), 1, + STATE(2573), 1, sym_on_stop_phrase, - STATE(2310), 1, + STATE(2574), 1, aux_sym_for_statement_repeat1, - STATE(1459), 2, + STATE(1843), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70763] = 19, - ACTIONS(373), 1, + [90129] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1980), 1, + ACTIONS(2758), 1, anon_sym_COLON, - STATE(1467), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1674), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1927), 1, + STATE(2196), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1971), 1, + STATE(2244), 1, sym_on_quit_phrase, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, + STATE(2576), 1, sym_on_stop_phrase, - STATE(1460), 2, + STATE(2577), 1, + aux_sym_for_statement_repeat1, + STATE(1844), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70826] = 19, - ACTIONS(373), 1, + [90176] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1960), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1665), 1, - aux_sym_for_phrase_repeat2, - STATE(1895), 1, - sym_on_error_phrase, - STATE(1947), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, - sym_on_stop_phrase, - STATE(1461), 2, + STATE(390), 1, + sym_accumulate_aggregate, + STATE(1845), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70889] = 19, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [90205] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(71), 1, + sym__namedot, + STATE(1846), 2, + sym_comment, + sym_include, + ACTIONS(69), 10, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(2010), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1646), 1, - aux_sym_for_phrase_repeat2, - STATE(1913), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1986), 1, - sym_on_quit_phrase, - STATE(2480), 1, - sym_on_stop_phrase, - STATE(2481), 1, - aux_sym_for_statement_repeat1, - STATE(1462), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [70952] = 19, - ACTIONS(373), 1, + [90234] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(2197), 1, + sym_sort_order, + STATE(1847), 2, + sym_comment, + sym_include, + ACTIONS(2423), 4, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + ACTIONS(2419), 6, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(2012), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1671), 1, - aux_sym_for_phrase_repeat2, - STATE(1869), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2027), 1, - sym_on_quit_phrase, - STATE(2362), 1, - sym_on_stop_phrase, - STATE(2363), 1, - aux_sym_for_statement_repeat1, - STATE(1463), 2, + [90265] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(426), 1, + sym_accumulate_aggregate, + STATE(1848), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71015] = 19, - ACTIONS(373), 1, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [90294] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2014), 1, + ACTIONS(2042), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1613), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1849), 1, + STATE(2199), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1972), 1, + STATE(2242), 1, sym_on_quit_phrase, - STATE(2409), 1, + STATE(2556), 1, aux_sym_for_statement_repeat1, - STATE(2411), 1, + STATE(2568), 1, sym_on_stop_phrase, - STATE(1464), 2, + STATE(1849), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71078] = 19, - ACTIONS(373), 1, + [90341] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(539), 1, + sym_accumulate_aggregate, + STATE(1850), 2, + sym_comment, + sym_include, + ACTIONS(2703), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [90370] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1982), 1, + ACTIONS(2760), 1, anon_sym_COLON, - STATE(1492), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1659), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1892), 1, + STATE(2178), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2014), 1, + STATE(2331), 1, sym_on_quit_phrase, - STATE(2489), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 1, + STATE(2800), 1, sym_on_stop_phrase, - STATE(1465), 2, + STATE(2801), 1, + aux_sym_for_statement_repeat1, + STATE(1851), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71141] = 19, - ACTIONS(373), 1, + [90417] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2016), 1, + ACTIONS(2074), 1, anon_sym_COLON, - STATE(1462), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1635), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1945), 1, + STATE(2125), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2011), 1, + STATE(2297), 1, sym_on_quit_phrase, - STATE(2374), 1, - aux_sym_for_statement_repeat1, - STATE(2393), 1, + STATE(2679), 1, sym_on_stop_phrase, - STATE(1466), 2, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(1852), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71204] = 19, - ACTIONS(373), 1, + [90464] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(2702), 1, + sym_accumulate_aggregate, + STATE(1853), 2, + sym_comment, + sym_include, + ACTIONS(2746), 10, + aux_sym_accumulate_aggregate_token1, + aux_sym_accumulate_aggregate_token2, + aux_sym_accumulate_aggregate_token3, + aux_sym_accumulate_aggregate_token4, + aux_sym_accumulate_aggregate_token5, + aux_sym_accumulate_aggregate_token6, + aux_sym_accumulate_aggregate_token7, + aux_sym_accumulate_aggregate_token8, + aux_sym_accumulate_aggregate_token9, + aux_sym_accumulate_aggregate_token10, + [90493] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2016), 1, + ACTIONS(2134), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1635), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1945), 1, + STATE(2179), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2011), 1, + STATE(2327), 1, sym_on_quit_phrase, - STATE(2374), 1, - aux_sym_for_statement_repeat1, - STATE(2393), 1, + STATE(2805), 1, sym_on_stop_phrase, - STATE(1467), 2, + STATE(2806), 1, + aux_sym_for_statement_repeat1, + STATE(1854), 2, + sym_comment, + sym_include, + [90540] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1855), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2762), 11, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [71267] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym__using_and_token1, + [90567] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2002), 1, + ACTIONS(2764), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1634), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1885), 1, + STATE(2182), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2026), 1, + STATE(2326), 1, sym_on_quit_phrase, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2356), 1, + STATE(2807), 1, sym_on_stop_phrase, - STATE(1468), 2, + STATE(2808), 1, + aux_sym_for_statement_repeat1, + STATE(1856), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71330] = 19, - ACTIONS(373), 1, + [90614] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2713), 1, + aux_sym_variable_definition_token1, + ACTIONS(2715), 1, + aux_sym_variable_definition_token2, + ACTIONS(2717), 1, + aux_sym_method_definition_token1, + ACTIONS(2766), 1, + aux_sym__block_terminator_token1, + STATE(1906), 1, + aux_sym_interface_body_repeat1, + STATE(3635), 1, + sym_interface_body, + STATE(1857), 2, + sym_comment, + sym_include, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [90653] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2012), 1, + ACTIONS(2136), 1, anon_sym_COLON, - STATE(1487), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1671), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1869), 1, + STATE(2184), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2027), 1, + STATE(2324), 1, sym_on_quit_phrase, - STATE(2362), 1, + STATE(2813), 1, sym_on_stop_phrase, - STATE(2363), 1, + STATE(2814), 1, aux_sym_for_statement_repeat1, - STATE(1469), 2, + STATE(1858), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71393] = 19, - ACTIONS(373), 1, + [90700] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1946), 1, + ACTIONS(2086), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1660), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1841), 1, + STATE(2170), 1, sym_on_error_phrase, - STATE(1948), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, + STATE(2256), 1, + sym_on_quit_phrase, + STATE(2604), 1, sym_on_stop_phrase, - STATE(1470), 2, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(1859), 2, + sym_comment, + sym_include, + [90747] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1860), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2768), 11, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [71456] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym__using_and_token1, + [90774] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1984), 1, + ACTIONS(2146), 1, anon_sym_COLON, - STATE(1496), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1667), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1840), 1, + STATE(2155), 1, sym_on_error_phrase, - STATE(1957), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2333), 1, + STATE(2337), 1, + sym_on_quit_phrase, + STATE(2763), 1, sym_on_stop_phrase, - STATE(2418), 1, + STATE(2789), 1, aux_sym_for_statement_repeat1, - STATE(1471), 2, + STATE(1861), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71519] = 19, - ACTIONS(373), 1, + [90821] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1946), 1, + ACTIONS(2138), 1, anon_sym_COLON, - STATE(1508), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1660), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1841), 1, + STATE(2188), 1, sym_on_error_phrase, - STATE(1948), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, + STATE(2322), 1, + sym_on_quit_phrase, + STATE(2816), 1, sym_on_stop_phrase, - STATE(1472), 2, + STATE(2817), 1, + aux_sym_for_statement_repeat1, + STATE(1862), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71582] = 19, - ACTIONS(373), 1, + [90868] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1960), 1, + ACTIONS(2132), 1, anon_sym_COLON, - STATE(1512), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1665), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1895), 1, + STATE(2194), 1, sym_on_error_phrase, - STATE(1947), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, + STATE(2245), 1, + sym_on_quit_phrase, + STATE(2589), 1, sym_on_stop_phrase, - STATE(1473), 2, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(1863), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71645] = 19, - ACTIONS(373), 1, + [90915] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1964), 1, + ACTIONS(2120), 1, anon_sym_COLON, - STATE(1500), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1666), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1881), 1, + STATE(2128), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2070), 1, + STATE(2296), 1, sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, + STATE(2678), 1, sym_on_stop_phrase, - STATE(1474), 2, + STATE(2705), 1, + aux_sym_for_statement_repeat1, + STATE(1864), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71708] = 19, - ACTIONS(373), 1, + [90962] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1986), 1, - anon_sym_COLON, - STATE(1468), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2688), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1680), 1, - aux_sym_for_phrase_repeat2, - STATE(1861), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1995), 1, - sym_on_quit_phrase, - STATE(2221), 1, - aux_sym_for_statement_repeat1, - STATE(2294), 1, - sym_on_stop_phrase, - STATE(1475), 2, + STATE(1969), 1, + aux_sym_for_phrase_repeat1, + STATE(1975), 1, + sym_where_clause, + STATE(1865), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [71771] = 19, - ACTIONS(373), 1, + [91001] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2018), 1, + ACTIONS(2110), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1686), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1933), 1, + STATE(2189), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1967), 1, + STATE(2320), 1, sym_on_quit_phrase, - STATE(2193), 1, + STATE(2820), 1, sym_on_stop_phrase, - STATE(2196), 1, + STATE(2821), 1, aux_sym_for_statement_repeat1, - STATE(1476), 2, + STATE(1866), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71834] = 19, - ACTIONS(373), 1, + [91048] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1982), 1, + ACTIONS(2040), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1659), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1892), 1, + STATE(2207), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2014), 1, + STATE(2303), 1, sym_on_quit_phrase, - STATE(2489), 1, + STATE(2851), 1, aux_sym_for_statement_repeat1, - STATE(2491), 1, + STATE(2852), 1, sym_on_stop_phrase, - STATE(1477), 2, + STATE(1867), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71897] = 19, - ACTIONS(373), 1, + [91095] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2020), 1, + ACTIONS(2102), 1, anon_sym_COLON, - STATE(1476), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1616), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1847), 1, + STATE(2122), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2072), 1, + STATE(2290), 1, sym_on_quit_phrase, - STATE(2330), 1, + STATE(2667), 1, sym_on_stop_phrase, - STATE(2339), 1, + STATE(2668), 1, aux_sym_for_statement_repeat1, - STATE(1478), 2, + STATE(1868), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [71960] = 19, - ACTIONS(373), 1, + [91142] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1978), 1, + ACTIONS(2140), 1, anon_sym_COLON, - STATE(1463), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1678), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1904), 1, + STATE(2191), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1998), 1, + STATE(2318), 1, sym_on_quit_phrase, - STATE(2391), 1, + STATE(2830), 1, sym_on_stop_phrase, - STATE(2392), 1, + STATE(2831), 1, aux_sym_for_statement_repeat1, - STATE(1479), 2, + STATE(1869), 2, + sym_comment, + sym_include, + [91189] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2713), 1, + aux_sym_variable_definition_token1, + ACTIONS(2715), 1, + aux_sym_variable_definition_token2, + ACTIONS(2717), 1, + aux_sym_method_definition_token1, + ACTIONS(2770), 1, + aux_sym__block_terminator_token1, + STATE(1906), 1, + aux_sym_interface_body_repeat1, + STATE(3593), 1, + sym_interface_body, + STATE(1870), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72023] = 19, - ACTIONS(373), 1, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [91228] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1962), 1, + ACTIONS(2164), 1, anon_sym_COLON, - STATE(1477), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1617), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1902), 1, + STATE(2193), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2050), 1, + STATE(2247), 1, sym_on_quit_phrase, - STATE(2375), 1, + STATE(2591), 1, sym_on_stop_phrase, - STATE(2380), 1, + STATE(2592), 1, aux_sym_for_statement_repeat1, - STATE(1480), 2, + STATE(1871), 2, + sym_comment, + sym_include, + [91275] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1872), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2772), 11, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [72086] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym__using_and_token1, + [91302] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1984), 1, + ACTIONS(2100), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1667), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1840), 1, + STATE(2187), 1, sym_on_error_phrase, - STATE(1957), 1, - sym_on_quit_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2333), 1, + STATE(2249), 1, + sym_on_quit_phrase, + STATE(2594), 1, sym_on_stop_phrase, - STATE(2418), 1, + STATE(2595), 1, aux_sym_for_statement_repeat1, - STATE(1481), 2, + STATE(1873), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72149] = 19, - ACTIONS(373), 1, + [91349] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1990), 1, + ACTIONS(2112), 1, anon_sym_COLON, - STATE(1456), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1629), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1926), 1, + STATE(2202), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2001), 1, + STATE(2309), 1, sym_on_quit_phrase, - STATE(2237), 1, + STATE(2840), 1, sym_on_stop_phrase, - STATE(2276), 1, + STATE(2841), 1, aux_sym_for_statement_repeat1, - STATE(1482), 2, + STATE(1874), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72212] = 19, - ACTIONS(373), 1, + [91396] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2713), 1, + aux_sym_variable_definition_token1, + ACTIONS(2715), 1, + aux_sym_variable_definition_token2, + ACTIONS(2717), 1, + aux_sym_method_definition_token1, + ACTIONS(2774), 1, + aux_sym__block_terminator_token1, + STATE(1906), 1, + aux_sym_interface_body_repeat1, + STATE(3773), 1, + sym_interface_body, + STATE(1875), 2, + sym_comment, + sym_include, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [91435] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2529), 1, + aux_sym_variable_tuning_token1, + STATE(1835), 1, + aux_sym_field_definition_repeat1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2533), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + STATE(1876), 2, + sym_comment, + sym_include, + ACTIONS(2527), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + ACTIONS(2531), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + [91472] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1986), 1, + ACTIONS(2776), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1680), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1861), 1, + STATE(2219), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1995), 1, + STATE(2252), 1, sym_on_quit_phrase, - STATE(2221), 1, + STATE(2825), 1, aux_sym_for_statement_repeat1, - STATE(2294), 1, + STATE(2839), 1, sym_on_stop_phrase, - STATE(1483), 2, + STATE(1877), 2, + sym_comment, + sym_include, + [91519] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1878), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2778), 11, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [72275] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + aux_sym__using_and_token1, + [91546] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2022), 1, + ACTIONS(2044), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1653), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1877), 1, + STATE(2195), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2036), 1, + STATE(2310), 1, sym_on_quit_phrase, - STATE(2282), 1, - sym_on_stop_phrase, - STATE(2284), 1, + STATE(2833), 1, aux_sym_for_statement_repeat1, - STATE(1484), 2, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(1879), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72338] = 19, - ACTIONS(373), 1, + [91593] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1988), 1, + ACTIONS(2104), 1, anon_sym_COLON, - STATE(1510), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1681), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1917), 1, + STATE(2192), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1983), 1, + STATE(2319), 1, sym_on_quit_phrase, - STATE(2210), 1, - sym_on_stop_phrase, - STATE(2231), 1, + STATE(2832), 1, aux_sym_for_statement_repeat1, - STATE(1485), 2, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(1880), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72401] = 19, - ACTIONS(373), 1, + [91640] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2529), 1, + aux_sym_variable_tuning_token1, + STATE(1821), 1, + aux_sym_field_definition_repeat1, + STATE(1945), 1, + sym_field_option, + ACTIONS(2533), 2, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + STATE(1881), 2, + sym_comment, + sym_include, + ACTIONS(2531), 3, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + ACTIONS(2780), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [91677] = 15, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1972), 1, + ACTIONS(2048), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1663), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1873), 1, + STATE(2173), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2030), 1, + STATE(2254), 1, sym_on_quit_phrase, - STATE(2434), 1, + STATE(2598), 1, aux_sym_for_statement_repeat1, - STATE(2435), 1, + STATE(2599), 1, sym_on_stop_phrase, - STATE(1486), 2, + STATE(1882), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72464] = 19, - ACTIONS(373), 1, + [91724] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2024), 1, + ACTIONS(2142), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1679), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1855), 1, + STATE(2185), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2058), 1, + STATE(2250), 1, sym_on_quit_phrase, - STATE(2317), 1, + STATE(2596), 1, sym_on_stop_phrase, - STATE(2320), 1, + STATE(2597), 1, aux_sym_for_statement_repeat1, - STATE(1487), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72527] = 17, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(2026), 1, - sym_identifier, - ACTIONS(2028), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2030), 1, - aux_sym_if_statement_token1, - ACTIONS(2032), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2034), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2036), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(955), 1, - sym_do_block, - STATE(958), 1, - sym__terminated_statement, - STATE(2647), 1, - sym_label, - STATE(3130), 1, - sym_assignment, - STATE(3131), 1, - sym_function_call, - STATE(942), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1488), 2, + STATE(1883), 2, sym_comment, sym_include, - STATE(957), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [72586] = 19, - ACTIONS(373), 1, + [91771] = 15, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1978), 1, + ACTIONS(2062), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1678), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1904), 1, + STATE(2135), 1, sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1998), 1, + STATE(2308), 1, sym_on_quit_phrase, - STATE(2391), 1, - sym_on_stop_phrase, - STATE(2392), 1, + STATE(2691), 1, aux_sym_for_statement_repeat1, - STATE(1489), 2, + STATE(2693), 1, + sym_on_stop_phrase, + STATE(1884), 2, + sym_comment, + sym_include, + [91818] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2672), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1977), 1, + sym_where_clause, + STATE(1978), 1, + aux_sym_for_phrase_repeat1, + STATE(1885), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [72649] = 19, - ACTIONS(373), 1, + [91857] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(988), 1, + aux_sym_where_clause_token1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1948), 1, - anon_sym_COLON, - STATE(1507), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2782), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1612), 1, - aux_sym_for_phrase_repeat2, - STATE(1839), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2075), 1, - sym_on_quit_phrase, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1490), 2, + STATE(1981), 1, + sym_where_clause, + STATE(1982), 1, + aux_sym_for_phrase_repeat1, + STATE(1886), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [72712] = 19, - ACTIONS(373), 1, + [91896] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2784), 1, + anon_sym_COLON, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1940), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + STATE(1918), 1, + aux_sym_do_block_repeat1, + STATE(2349), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1887), 2, + sym_comment, + sym_include, + STATE(3484), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [91936] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2792), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1626), 1, - aux_sym_for_phrase_repeat2, - STATE(1921), 1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2238), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1888), 2, + sym_comment, + sym_include, + STATE(3434), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1990), 1, + sym_on_stop_phrase, sym_on_quit_phrase, - STATE(2209), 1, + [91976] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2794), 1, + anon_sym_COLON, + STATE(1901), 1, + aux_sym_do_block_repeat1, + STATE(2313), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1889), 2, + sym_comment, + sym_include, + STATE(3425), 3, + sym_on_error_phrase, sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1491), 2, + sym_on_quit_phrase, + [92016] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2796), 1, + anon_sym_COLON, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2237), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1890), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72775] = 19, - ACTIONS(373), 1, + STATE(3589), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92056] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2794), 1, + anon_sym_COLON, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2313), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1891), 2, + sym_comment, + sym_include, + STATE(3425), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92096] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(2798), 1, + sym_identifier, + STATE(1897), 1, + aux_sym_sort_clause_repeat1, + STATE(2190), 1, + sym_sort_column, + STATE(1847), 2, + sym_qualified_name, + sym_function_call, + STATE(1892), 2, + sym_comment, + sym_include, + ACTIONS(2800), 5, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [92130] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(1893), 2, + sym_comment, + sym_include, + ACTIONS(432), 10, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(2020), 1, + [92156] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2802), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1616), 1, - aux_sym_for_phrase_repeat2, - STATE(1847), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2072), 1, - sym_on_quit_phrase, - STATE(2330), 1, - sym_on_stop_phrase, - STATE(2339), 1, - aux_sym_for_statement_repeat1, - STATE(1492), 2, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2225), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1894), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72838] = 19, - ACTIONS(373), 1, + STATE(3726), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92196] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1962), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2804), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1617), 1, - aux_sym_for_phrase_repeat2, - STATE(1902), 1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2307), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1895), 2, + sym_comment, + sym_include, + STATE(3376), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2050), 1, - sym_on_quit_phrase, - STATE(2375), 1, sym_on_stop_phrase, - STATE(2380), 1, - aux_sym_for_statement_repeat1, - STATE(1493), 2, + sym_on_quit_phrase, + [92236] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(920), 1, + sym__integer_literal, + ACTIONS(926), 1, + anon_sym_LPAREN, + ACTIONS(2806), 1, + sym_identifier, + STATE(646), 1, + sym__decimal_literal, + STATE(660), 1, + sym__unary_minus_expressions, + STATE(1896), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72901] = 19, - ACTIONS(373), 1, + STATE(642), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [92272] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2808), 1, + sym_identifier, + STATE(2190), 1, + sym_sort_column, + STATE(1847), 2, + sym_qualified_name, + sym_function_call, + STATE(1897), 3, + sym_comment, + sym_include, + aux_sym_sort_clause_repeat1, + ACTIONS(2811), 5, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(1964), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1666), 1, - aux_sym_for_phrase_repeat2, - STATE(1881), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2070), 1, - sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, - sym_on_stop_phrase, - STATE(1494), 2, + [92304] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(876), 1, + sym__integer_literal, + ACTIONS(882), 1, + anon_sym_LPAREN, + ACTIONS(2813), 1, + sym_identifier, + STATE(884), 1, + sym__unary_minus_expressions, + STATE(887), 1, + sym__decimal_literal, + STATE(1898), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [72964] = 19, - ACTIONS(373), 1, + STATE(895), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [92340] = 14, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1948), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1612), 1, - aux_sym_for_phrase_repeat2, - STATE(1839), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2075), 1, - sym_on_quit_phrase, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1495), 2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1044), 1, + aux_sym_widget_field_token1, + STATE(1305), 1, + sym_do_block, + STATE(2038), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(1899), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73027] = 19, - ACTIONS(373), 1, + [92384] = 14, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + ACTIONS(2815), 1, + aux_sym_widget_field_token1, + STATE(1268), 1, + sym_do_block, + STATE(2056), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(1900), 2, + sym_comment, + sym_include, + [92428] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2038), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2817), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1657), 1, - aux_sym_for_phrase_repeat2, - STATE(1852), 1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2298), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1901), 2, + sym_comment, + sym_include, + STATE(3442), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2046), 1, - sym_on_quit_phrase, - STATE(2542), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 1, sym_on_stop_phrase, - STATE(1496), 2, + sym_on_quit_phrase, + [92468] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(428), 1, + aux_sym_variable_definition_token2, + STATE(1902), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73090] = 19, - ACTIONS(373), 1, + ACTIONS(430), 9, + aux_sym__block_terminator_token1, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [92496] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2040), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2819), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1628), 1, - aux_sym_for_phrase_repeat2, - STATE(1903), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2000), 1, - sym_on_quit_phrase, - STATE(2315), 1, - sym_on_stop_phrase, - STATE(2329), 1, - aux_sym_for_statement_repeat1, - STATE(1497), 2, + STATE(1895), 1, + aux_sym_do_block_repeat1, + STATE(2301), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1903), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73153] = 19, - ACTIONS(373), 1, + STATE(3638), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92536] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(2042), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1644), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1862), 1, - sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2062), 1, + STATE(2315), 1, + sym_on_error_phrase, + STATE(2393), 1, sym_on_quit_phrase, - STATE(2531), 1, - aux_sym_for_statement_repeat1, - STATE(2541), 1, + STATE(3351), 1, sym_on_stop_phrase, - STATE(1498), 2, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1904), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73216] = 19, - ACTIONS(373), 1, + [92578] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2038), 1, + ACTIONS(2784), 1, anon_sym_COLON, - STATE(1514), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1657), 1, - aux_sym_for_phrase_repeat2, - STATE(1852), 1, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2349), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1905), 2, + sym_comment, + sym_include, + STATE(3484), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2046), 1, - sym_on_quit_phrase, - STATE(2542), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 1, sym_on_stop_phrase, - STATE(1499), 2, + sym_on_quit_phrase, + [92618] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2713), 1, + aux_sym_variable_definition_token1, + ACTIONS(2715), 1, + aux_sym_variable_definition_token2, + ACTIONS(2717), 1, + aux_sym_method_definition_token1, + ACTIONS(2821), 1, + aux_sym__block_terminator_token1, + STATE(1929), 1, + aux_sym_interface_body_repeat1, + STATE(1906), 2, + sym_comment, + sym_include, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [92654] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1907), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(2823), 10, + anon_sym_RPAREN, + aux_sym_where_clause_token1, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [73279] = 19, - ACTIONS(373), 1, + aux_sym_query_tuning_token6, + aux_sym_of_token1, + aux_sym__using_first_token1, + [92680] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(2798), 1, + sym_identifier, + STATE(1897), 1, + aux_sym_sort_clause_repeat1, + STATE(2190), 1, + sym_sort_column, + STATE(1847), 2, + sym_qualified_name, + sym_function_call, + STATE(1908), 2, + sym_comment, + sym_include, + ACTIONS(2825), 5, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(1990), 1, + [92714] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2827), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1629), 1, - aux_sym_for_phrase_repeat2, - STATE(1926), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2001), 1, - sym_on_quit_phrase, - STATE(2237), 1, - sym_on_stop_phrase, + STATE(2206), 1, + aux_sym_do_block_repeat1, STATE(2276), 1, - aux_sym_for_statement_repeat1, - STATE(1500), 2, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1909), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73342] = 19, - ACTIONS(373), 1, + STATE(3678), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92754] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1976), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2827), 1, anon_sym_COLON, - STATE(1459), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1690), 1, - aux_sym_for_phrase_repeat2, - STATE(1898), 1, + STATE(1917), 1, + aux_sym_do_block_repeat1, + STATE(2276), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1910), 2, + sym_comment, + sym_include, + STATE(3678), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2065), 1, - sym_on_quit_phrase, - STATE(2336), 1, sym_on_stop_phrase, - STATE(2342), 1, - aux_sym_for_statement_repeat1, - STATE(1501), 2, + sym_on_quit_phrase, + [92794] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(2829), 1, + sym_identifier, + STATE(301), 1, + sym__decimal_literal, + STATE(341), 1, + sym__unary_minus_expressions, + STATE(1911), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73405] = 19, - ACTIONS(373), 1, + STATE(335), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [92830] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1966), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2802), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1685), 1, - aux_sym_for_phrase_repeat2, - STATE(1942), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(1502), 2, + STATE(1890), 1, + aux_sym_do_block_repeat1, + STATE(2225), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1912), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73468] = 19, - ACTIONS(373), 1, + STATE(3726), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [92870] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1968), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2792), 1, anon_sym_COLON, - STATE(1489), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1611), 1, - aux_sym_for_phrase_repeat2, - STATE(1941), 1, + STATE(1894), 1, + aux_sym_do_block_repeat1, + STATE(2238), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1913), 2, + sym_comment, + sym_include, + STATE(3434), 3, sym_on_error_phrase, - STATE(1960), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, sym_on_stop_phrase, - STATE(1503), 2, + sym_on_quit_phrase, + [92910] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(2831), 1, + sym_identifier, + STATE(301), 1, + sym__decimal_literal, + STATE(341), 1, + sym__unary_minus_expressions, + STATE(1914), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73531] = 19, - ACTIONS(373), 1, + STATE(335), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [92946] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - ACTIONS(1940), 1, - anon_sym_COLON, - STATE(1481), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1626), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1921), 1, - sym_on_error_phrase, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1990), 1, + STATE(2253), 1, + sym_on_error_phrase, + STATE(2453), 1, sym_on_quit_phrase, - STATE(2209), 1, + STATE(3098), 1, sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1504), 2, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(1915), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73594] = 19, - ACTIONS(373), 1, + [92988] = 14, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2044), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1658), 1, - aux_sym_for_phrase_repeat2, - STATE(1851), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2061), 1, - sym_on_quit_phrase, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 1, - sym_on_stop_phrase, - STATE(1505), 2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1040), 1, + aux_sym_widget_field_token1, + STATE(1421), 1, + sym_do_block, + STATE(2090), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(1916), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73657] = 19, - ACTIONS(373), 1, + [93032] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2044), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2819), 1, anon_sym_COLON, - STATE(1517), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1658), 1, - aux_sym_for_phrase_repeat2, - STATE(1851), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2061), 1, - sym_on_quit_phrase, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 1, - sym_on_stop_phrase, - STATE(1506), 2, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2301), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1917), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73720] = 19, - ACTIONS(373), 1, + STATE(3638), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93072] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1974), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2833), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1656), 1, - aux_sym_for_phrase_repeat2, - STATE(1860), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2051), 1, - sym_on_quit_phrase, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(1507), 2, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2356), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1918), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73783] = 19, - ACTIONS(373), 1, + STATE(3468), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93112] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1988), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2833), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1681), 1, - aux_sym_for_phrase_repeat2, - STATE(1917), 1, + STATE(1924), 1, + aux_sym_do_block_repeat1, + STATE(2356), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1919), 2, + sym_comment, + sym_include, + STATE(3468), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1983), 1, - sym_on_quit_phrase, - STATE(2210), 1, sym_on_stop_phrase, - STATE(2231), 1, - aux_sym_for_statement_repeat1, - STATE(1508), 2, + sym_on_quit_phrase, + [93152] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1920), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73846] = 19, - ACTIONS(373), 1, + ACTIONS(2835), 8, + aux_sym_serialization_tuning_token1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [93182] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, + STATE(1921), 2, + sym_comment, + sym_include, + ACTIONS(436), 10, + sym_identifier, anon_sym_COMMA, - ACTIONS(1190), 1, + anon_sym_COLON, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, aux_sym_sort_clause_token2, - ACTIONS(1974), 1, - anon_sym_COLON, - STATE(1448), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1656), 1, - aux_sym_for_phrase_repeat2, - STATE(1860), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2051), 1, - sym_on_quit_phrase, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(1509), 2, + [93208] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(782), 1, + sym__integer_literal, + ACTIONS(788), 1, + anon_sym_LPAREN, + ACTIONS(2837), 1, + sym_identifier, + STATE(810), 1, + sym__unary_minus_expressions, + STATE(819), 1, + sym__decimal_literal, + STATE(1922), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73909] = 19, - ACTIONS(373), 1, + STATE(811), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [93244] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2046), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2839), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1655), 1, - aux_sym_for_phrase_repeat2, - STATE(1912), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1981), 1, - sym_on_quit_phrase, - STATE(2195), 1, - aux_sym_for_statement_repeat1, - STATE(2202), 1, - sym_on_stop_phrase, - STATE(1510), 2, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2257), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1923), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [73972] = 19, - ACTIONS(373), 1, + STATE(3585), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93284] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2000), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2841), 1, anon_sym_COLON, - STATE(1497), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1636), 1, - aux_sym_for_phrase_repeat2, - STATE(1890), 1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2353), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1924), 2, + sym_comment, + sym_include, + STATE(3447), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2021), 1, - sym_on_quit_phrase, - STATE(2419), 1, sym_on_stop_phrase, - STATE(2420), 1, - aux_sym_for_statement_repeat1, - STATE(1511), 2, + sym_on_quit_phrase, + [93324] = 12, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2843), 1, + anon_sym_COLON, + STATE(1923), 1, + aux_sym_do_block_repeat1, + STATE(2267), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1925), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74035] = 19, - ACTIONS(373), 1, + STATE(3567), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93364] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1976), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2843), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1690), 1, - aux_sym_for_phrase_repeat2, - STATE(1898), 1, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2267), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1926), 2, + sym_comment, + sym_include, + STATE(3567), 3, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2065), 1, - sym_on_quit_phrase, - STATE(2336), 1, sym_on_stop_phrase, - STATE(2342), 1, - aux_sym_for_statement_repeat1, - STATE(1512), 2, + sym_on_quit_phrase, + [93404] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(836), 1, + sym__integer_literal, + ACTIONS(842), 1, + anon_sym_LPAREN, + ACTIONS(2845), 1, + sym_identifier, + STATE(918), 1, + sym__unary_minus_expressions, + STATE(929), 1, + sym__decimal_literal, + STATE(1927), 2, + sym_comment, + sym_include, + STATE(925), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [93440] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(2654), 1, + sym__namedot, + STATE(1934), 1, + aux_sym_qualified_name_repeat1, + STATE(1928), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74098] = 19, - ACTIONS(373), 1, + ACTIONS(61), 8, + sym_identifier, + sym__terminator, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [93470] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1966), 1, - anon_sym_COLON, - STATE(1483), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1685), 1, - aux_sym_for_phrase_repeat2, - STATE(1942), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(1513), 2, + ACTIONS(2847), 1, + aux_sym__block_terminator_token1, + ACTIONS(2849), 1, + aux_sym_variable_definition_token1, + ACTIONS(2852), 1, + aux_sym_variable_definition_token2, + ACTIONS(2855), 1, + aux_sym_method_definition_token1, + STATE(1929), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74161] = 19, - ACTIONS(373), 1, + aux_sym_interface_body_repeat1, + STATE(2485), 5, + sym_property_definition, + sym_event_definition, + sym_method_definition, + sym_dataset_definition, + sym_temp_table_definition, + [93504] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2048), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2858), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1645), 1, - aux_sym_for_phrase_repeat2, - STATE(1858), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2057), 1, - sym_on_quit_phrase, - STATE(2305), 1, - aux_sym_for_statement_repeat1, - STATE(2306), 1, - sym_on_stop_phrase, - STATE(1514), 2, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2272), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1930), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74224] = 19, - ACTIONS(373), 1, + STATE(3546), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93544] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1968), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2858), 1, anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1611), 1, - aux_sym_for_phrase_repeat2, - STATE(1941), 1, + STATE(1926), 1, + aux_sym_do_block_repeat1, + STATE(2272), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1931), 2, + sym_comment, + sym_include, + STATE(3546), 3, sym_on_error_phrase, - STATE(1960), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, sym_on_stop_phrase, - STATE(1515), 2, + sym_on_quit_phrase, + [93584] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(422), 1, + aux_sym_variable_definition_token2, + STATE(1932), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74287] = 19, - ACTIONS(373), 1, + ACTIONS(424), 9, + aux_sym__block_terminator_token1, + aux_sym_variable_tuning_token6, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [93612] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2046), 1, - anon_sym_COLON, - STATE(1452), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1655), 1, - aux_sym_for_phrase_repeat2, - STATE(1912), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1981), 1, - sym_on_quit_phrase, - STATE(2195), 1, - aux_sym_for_statement_repeat1, - STATE(2202), 1, - sym_on_stop_phrase, - STATE(1516), 2, + ACTIONS(568), 1, + sym__integer_literal, + ACTIONS(671), 1, + anon_sym_LPAREN, + ACTIONS(2860), 1, + sym_identifier, + STATE(559), 1, + sym__unary_minus_expressions, + STATE(573), 1, + sym__decimal_literal, + STATE(1933), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74350] = 19, - ACTIONS(373), 1, + STATE(555), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [93648] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2050), 1, - anon_sym_COLON, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1642), 1, - aux_sym_for_phrase_repeat2, - STATE(1866), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2045), 1, - sym_on_quit_phrase, - STATE(2530), 1, - aux_sym_for_statement_repeat1, - STATE(2553), 1, - sym_on_stop_phrase, - STATE(1517), 2, + ACTIONS(2862), 1, + sym__namedot, + STATE(1934), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74413] = 17, + aux_sym_qualified_name_repeat1, + ACTIONS(69), 8, + sym_identifier, + sym__terminator, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [93676] = 14, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2052), 1, + ACTIONS(1026), 1, sym_identifier, - ACTIONS(2054), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2056), 1, - aux_sym_if_statement_token1, - ACTIONS(2058), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2060), 1, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1036), 1, aux_sym_do_while_statement_token1, - ACTIONS(2062), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(999), 1, - sym__terminated_statement, - STATE(1000), 1, + ACTIONS(1042), 1, + aux_sym_widget_field_token1, + STATE(1451), 1, sym_do_block, - STATE(2709), 1, + STATE(2055), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, sym_label, - STATE(3102), 1, - sym_function_call, - STATE(3104), 1, - sym_assignment, - STATE(962), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1518), 2, + STATE(1935), 2, sym_comment, sym_include, - STATE(1001), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [74472] = 7, - ACTIONS(373), 1, + [93720] = 14, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1519), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + ACTIONS(1034), 1, + aux_sym_widget_field_token1, + STATE(1244), 1, + sym_do_block, + STATE(2082), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(1936), 2, sym_comment, sym_include, - ACTIONS(2064), 16, - sym__terminator, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [74510] = 16, + [93764] = 14, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2026), 1, + ACTIONS(1026), 1, sym_identifier, - ACTIONS(2028), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2032), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2034), 1, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1030), 1, + anon_sym_COMMA, + ACTIONS(1032), 1, aux_sym_do_while_statement_token1, - ACTIONS(2036), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(955), 1, + ACTIONS(2865), 1, + aux_sym_widget_field_token1, + STATE(1159), 1, sym_do_block, - STATE(958), 1, - sym__terminated_statement, - STATE(2647), 1, + STATE(2073), 1, + aux_sym_on_statement_repeat2, + STATE(2181), 1, + aux_sym_on_statement_repeat1, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, sym_label, - STATE(3130), 1, - sym_assignment, - STATE(3131), 1, - sym_function_call, - STATE(931), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1520), 2, + STATE(1937), 2, sym_comment, sym_include, - STATE(957), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [74566] = 17, - ACTIONS(373), 1, + [93808] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2867), 1, + anon_sym_COLON, + STATE(1891), 1, + aux_sym_do_block_repeat1, + STATE(2323), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1938), 2, + sym_comment, + sym_include, + STATE(3411), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93848] = 13, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1527), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1697), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2041), 1, + STATE(2255), 1, sym_on_error_phrase, - STATE(2095), 1, + STATE(2451), 1, sym_on_quit_phrase, - STATE(2966), 1, + STATE(3086), 1, sym_on_stop_phrase, - ACTIONS(1996), 2, + ACTIONS(2186), 2, anon_sym_COMMA, anon_sym_COLON, - STATE(1521), 2, - sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74624] = 16, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(2052), 1, - sym_identifier, - ACTIONS(2054), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2058), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2060), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2062), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(999), 1, - sym__terminated_statement, - STATE(1000), 1, - sym_do_block, - STATE(2709), 1, - sym_label, - STATE(3102), 1, - sym_function_call, - STATE(3104), 1, - sym_assignment, - STATE(817), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1522), 2, + STATE(1939), 2, sym_comment, sym_include, - STATE(1001), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [74680] = 17, - ACTIONS(373), 1, + [93890] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1709), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(2013), 1, + STATE(2279), 1, sym_on_error_phrase, - STATE(2143), 1, + STATE(2413), 1, sym_on_quit_phrase, - STATE(2929), 1, + STATE(3022), 1, sym_on_stop_phrase, - ACTIONS(1970), 2, + ACTIONS(2869), 2, anon_sym_COMMA, anon_sym_COLON, - STATE(1523), 2, + STATE(1940), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74738] = 16, - ACTIONS(3), 1, + [93932] = 12, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2052), 1, - sym_identifier, - ACTIONS(2054), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2058), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2060), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2062), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(999), 1, - sym__terminated_statement, - STATE(1000), 1, - sym_do_block, - STATE(2709), 1, - sym_label, - STATE(3102), 1, - sym_function_call, - STATE(3104), 1, - sym_assignment, - STATE(1002), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1524), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2788), 1, + aux_sym_stop_after_phrase_token1, + ACTIONS(2790), 1, + aux_sym_do_tuning_token1, + ACTIONS(2867), 1, + anon_sym_COLON, + STATE(2206), 1, + aux_sym_do_block_repeat1, + STATE(2323), 1, + sym_stop_after_phrase, + STATE(2427), 1, + sym_do_tuning, + STATE(1941), 2, sym_comment, sym_include, - STATE(1001), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [74794] = 17, - ACTIONS(373), 1, + STATE(3411), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [93972] = 13, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, + ACTIONS(1286), 1, aux_sym_sort_clause_token1, - ACTIONS(1196), 1, + ACTIONS(1288), 1, aux_sym_sort_clause_token2, - STATE(1528), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1698), 1, + STATE(2074), 1, aux_sym_for_phrase_repeat2, - STATE(1962), 1, + STATE(2227), 1, sym_sort_clause, - STATE(1976), 1, + STATE(2265), 1, sym_on_error_phrase, - STATE(2101), 1, + STATE(2435), 1, sym_on_quit_phrase, - STATE(2962), 1, + STATE(3137), 1, sym_on_stop_phrase, - ACTIONS(2066), 2, + ACTIONS(2182), 2, anon_sym_COMMA, anon_sym_COLON, - STATE(1525), 2, + STATE(1942), 2, + sym_comment, + sym_include, + [94014] = 10, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(134), 1, + sym__integer_literal, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(2871), 1, + sym_identifier, + STATE(301), 1, + sym__decimal_literal, + STATE(341), 1, + sym__unary_minus_expressions, + STATE(1943), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [74852] = 17, - ACTIONS(373), 1, + STATE(335), 5, + sym_qualified_name, + sym_number_literal, + sym_parenthesized_expression, + sym_function_call, + sym_object_access, + [94050] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1529), 1, + ACTIONS(2873), 1, + sym__terminator, + STATE(1694), 1, aux_sym_for_phrase_repeat1, - STATE(1597), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1709), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2013), 1, - sym_on_error_phrase, - STATE(2143), 1, - sym_on_quit_phrase, - STATE(2929), 1, - sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1526), 2, + STATE(1944), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [74910] = 17, - ACTIONS(373), 1, + [94083] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + STATE(1945), 2, + sym_comment, + sym_include, + ACTIONS(2875), 9, + sym__terminator, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [94108] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1573), 1, + ACTIONS(2877), 1, + sym__terminator, + STATE(1694), 1, aux_sym_for_phrase_repeat1, - STATE(1597), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1698), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(1976), 1, - sym_on_error_phrase, - STATE(2101), 1, - sym_on_quit_phrase, - STATE(2962), 1, - sym_on_stop_phrase, - ACTIONS(2066), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1527), 2, + STATE(1946), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [74968] = 17, - ACTIONS(373), 1, + [94141] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1573), 1, + ACTIONS(2879), 1, + sym__terminator, + STATE(1694), 1, aux_sym_for_phrase_repeat1, - STATE(1597), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1705), 1, - aux_sym_for_phrase_repeat2, - STATE(1946), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2111), 1, - sym_on_quit_phrase, - STATE(2957), 1, - sym_on_stop_phrase, - ACTIONS(2068), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1528), 2, + STATE(1947), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75026] = 17, - ACTIONS(373), 1, + [94174] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, + ACTIONS(2879), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - STATE(1697), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2041), 1, - sym_on_error_phrase, - STATE(2095), 1, - sym_on_quit_phrase, - STATE(2966), 1, - sym_on_stop_phrase, - ACTIONS(1996), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1529), 2, + STATE(1944), 1, + aux_sym_for_phrase_repeat1, + STATE(1948), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75084] = 16, - ACTIONS(3), 1, + [94207] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2026), 1, - sym_identifier, - ACTIONS(2028), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2032), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2034), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2036), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(955), 1, - sym_do_block, - STATE(958), 1, - sym__terminated_statement, - STATE(2647), 1, - sym_label, - STATE(3130), 1, - sym_assignment, - STATE(3131), 1, - sym_function_call, - STATE(829), 2, - sym__if_do_variant, - sym__if_then_variant, - STATE(1530), 2, + ACTIONS(2881), 1, + sym__terminator, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1949), 2, sym_comment, sym_include, - STATE(957), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [75140] = 15, - ACTIONS(3), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94240] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2070), 1, - sym_identifier, - ACTIONS(2072), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2074), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2076), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2078), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2240), 1, - sym__case_branch_body, - STATE(2617), 1, - sym_label, - STATE(3161), 1, - sym_assignment, - STATE(3162), 1, - sym_function_call, - STATE(1531), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2887), 1, + sym__terminator, + STATE(1957), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1950), 2, sym_comment, sym_include, - STATE(2230), 2, - sym__terminated_statement, - sym_do_block, - STATE(2322), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [75193] = 15, - ACTIONS(3), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94273] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2070), 1, - sym_identifier, - ACTIONS(2072), 1, - aux_sym_buffer_definition_token2, - ACTIONS(2074), 1, - aux_sym_repeat_statement_token1, - ACTIONS(2076), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2078), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2617), 1, - sym_label, - STATE(3028), 1, - sym__case_branch_body, - STATE(3161), 1, - sym_assignment, - STATE(3162), 1, - sym_function_call, - STATE(1532), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2889), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1951), 2, sym_comment, sym_include, - STATE(2230), 2, - sym__terminated_statement, - sym_do_block, - STATE(2322), 6, - sym_variable_assignment, - sym_function_call_statement, - sym_repeat_statement, - sym_return_statement, - sym_for_statement, - sym_abl_statement, - [75246] = 5, - ACTIONS(373), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94306] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1533), 2, + STATE(1952), 2, sym_comment, sym_include, - ACTIONS(2080), 16, + ACTIONS(1051), 9, sym__terminator, - anon_sym_RPAREN, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_property_definition_token2, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [94331] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2893), 1, + aux_sym_variable_definition_token2, + STATE(1953), 2, + sym_comment, + sym_include, + ACTIONS(2891), 8, + aux_sym__block_terminator_token1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [94358] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2897), 1, + anon_sym_LIKE, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(1954), 2, + sym_comment, + sym_include, + ACTIONS(2895), 6, + sym__terminator, + aux_sym_variable_tuning_token6, + aux_sym_variable_definition_token6, + aux_sym_temp_table_tuning_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [94389] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2901), 1, + aux_sym_variable_definition_token2, + STATE(1955), 2, + sym_comment, + sym_include, + ACTIONS(2899), 8, + aux_sym__block_terminator_token1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [94416] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2632), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1956), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [75278] = 12, - ACTIONS(373), 1, + [94449] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2082), 1, - aux_sym_variable_definition_token3, - ACTIONS(2084), 1, - aux_sym_variable_definition_token4, - ACTIONS(2086), 1, - aux_sym_buffer_definition_token3, - STATE(1538), 1, - aux_sym_variable_definition_repeat1, - ACTIONS(1456), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - STATE(1534), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2903), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1957), 2, sym_comment, sym_include, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - STATE(1605), 3, - sym_scope_tuning, - sym_access_tuning, - sym_serialization_tuning, - ACTIONS(1452), 4, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94482] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2905), 1, + sym__terminator, + STATE(1951), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1958), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94515] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2907), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1959), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94548] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(1960), 2, + sym_comment, + sym_include, + ACTIONS(2502), 9, aux_sym_scope_tuning_token1, aux_sym_scope_tuning_token2, aux_sym_scope_tuning_token3, aux_sym_scope_tuning_token4, - [75324] = 16, - ACTIONS(373), 1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_buffer_definition_token1, + aux_sym_query_definition_token1, + [94573] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2909), 1, + sym__terminator, + STATE(1973), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1961), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94606] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2916), 1, + anon_sym_LIKE, + STATE(2084), 1, + sym_temp_table_tuning, + ACTIONS(2913), 2, + aux_sym_variable_tuning_token6, + aux_sym_temp_table_tuning_token1, + STATE(1962), 3, + sym_comment, + sym_include, + aux_sym_temp_table_definition_repeat1, + ACTIONS(2911), 4, + sym__terminator, + aux_sym_variable_definition_token6, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [94637] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2919), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1963), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94670] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2921), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1964), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94703] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2923), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1965), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94736] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2707), 1, + anon_sym_COMMA, + STATE(1979), 1, + aux_sym_inherits_repeat1, + STATE(1966), 2, + sym_comment, + sym_include, + ACTIONS(2925), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [94765] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2927), 1, + sym__terminator, + STATE(1949), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1967), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94798] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2707), 1, + anon_sym_COMMA, + STATE(1966), 1, + aux_sym_inherits_repeat1, + STATE(1968), 2, + sym_comment, + sym_include, + ACTIONS(2719), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [94827] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2088), 1, + ACTIONS(2748), 1, sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1601), 1, - sym_of, - STATE(1661), 1, - sym__pre_tuning, - STATE(1746), 1, - sym_where_clause, - STATE(1748), 1, + STATE(1694), 1, aux_sym_for_phrase_repeat1, - STATE(1535), 2, + STATE(1795), 1, + sym_query_tuning, + STATE(1969), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75378] = 5, - ACTIONS(373), 1, + [94860] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1536), 2, + ACTIONS(2707), 1, + anon_sym_COMMA, + STATE(1979), 1, + aux_sym_inherits_repeat1, + STATE(1970), 2, sym_comment, sym_include, - ACTIONS(2064), 16, - sym__terminator, - anon_sym_RPAREN, - anon_sym_COMMA, + ACTIONS(2929), 7, + aux_sym_serialization_tuning_token1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [75410] = 5, - ACTIONS(373), 1, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [94889] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1537), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2931), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1971), 2, sym_comment, sym_include, - ACTIONS(2090), 16, - sym__terminator, - anon_sym_RPAREN, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94922] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2707), 1, anon_sym_COMMA, + STATE(1970), 1, + aux_sym_inherits_repeat1, + STATE(1972), 2, + sym_comment, + sym_include, + ACTIONS(2705), 7, + aux_sym_serialization_tuning_token1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - aux_sym_of_token1, - aux_sym__using_first_token1, - [75442] = 10, - ACTIONS(373), 1, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [94951] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2103), 1, - aux_sym_variable_definition_token4, - ACTIONS(2098), 2, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - ACTIONS(2101), 2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token3, - ACTIONS(2095), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - STATE(1538), 3, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2933), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1973), 2, sym_comment, sym_include, - aux_sym_variable_definition_repeat1, - STATE(1605), 3, - sym_scope_tuning, - sym_access_tuning, - sym_serialization_tuning, - ACTIONS(2092), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [75484] = 12, - ACTIONS(373), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [94984] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2105), 1, - aux_sym_variable_definition_token3, - ACTIONS(2107), 1, - aux_sym_variable_definition_token4, - ACTIONS(2109), 1, - aux_sym_buffer_definition_token3, - STATE(1538), 1, - aux_sym_variable_definition_repeat1, - ACTIONS(1456), 2, + ACTIONS(2935), 1, + aux_sym_property_definition_token1, + ACTIONS(2937), 1, + aux_sym_event_definition_token1, + STATE(2012), 1, + aux_sym_property_definition_repeat1, + STATE(2130), 1, + sym_property_tuning, + STATE(3640), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, aux_sym_serialization_tuning_token1, aux_sym_serialization_tuning_token2, - STATE(1539), 2, + ACTIONS(2094), 2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + STATE(1974), 2, sym_comment, sym_include, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - STATE(1605), 3, - sym_scope_tuning, - sym_access_tuning, - sym_serialization_tuning, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [75530] = 16, - ACTIONS(373), 1, + [95021] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2111), 1, + ACTIONS(2748), 1, sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1575), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1591), 1, - sym_of, - STATE(1677), 1, - sym__pre_tuning, - STATE(1738), 1, - sym_where_clause, - STATE(1739), 1, + STATE(1989), 1, aux_sym_for_phrase_repeat1, - STATE(1540), 2, + STATE(1975), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75584] = 16, - ACTIONS(373), 1, + [95054] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2113), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1575), 1, - sym_query_tuning, - STATE(1608), 1, - sym_of, - STATE(1618), 1, - sym__pre_tuning, - STATE(1765), 1, - sym_where_clause, - STATE(1769), 1, - aux_sym_for_phrase_repeat1, - STATE(1541), 2, + ACTIONS(2195), 1, + aux_sym_property_definition_token1, + ACTIONS(2197), 1, + aux_sym_event_definition_token1, + STATE(2012), 1, + aux_sym_property_definition_repeat1, + STATE(2130), 1, + sym_property_tuning, + STATE(3539), 1, + sym_serialization_tuning, + ACTIONS(2008), 2, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + ACTIONS(2094), 2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + STATE(1976), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [75638] = 16, - ACTIONS(373), 1, + [95091] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2115), 1, + ACTIONS(2754), 1, sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1575), 1, + STATE(1795), 1, sym_query_tuning, - STATE(1603), 1, - sym_of, - STATE(1654), 1, - sym__pre_tuning, - STATE(1761), 1, - sym_where_clause, - STATE(1762), 1, + STATE(1947), 1, aux_sym_for_phrase_repeat1, - STATE(1542), 2, + STATE(1977), 2, sym_comment, sym_include, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75692] = 13, - ACTIONS(373), 1, + [95124] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2117), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1543), 2, + ACTIONS(2754), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1978), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75739] = 15, - ACTIONS(373), 1, + [95157] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(2119), 1, + ACTIONS(2939), 1, + anon_sym_COMMA, + STATE(1979), 3, + sym_comment, + sym_include, + aux_sym_inherits_repeat1, + ACTIONS(2835), 7, aux_sym_serialization_tuning_token1, - ACTIONS(2121), 1, anon_sym_COLON, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, aux_sym_implements_token1, - ACTIONS(2127), 1, aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, aux_sym_final_token1, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1584), 1, - aux_sym_class_statement_repeat1, - STATE(1544), 2, + [95184] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2942), 1, + sym__terminator, + STATE(1995), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1980), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [75790] = 13, - ACTIONS(373), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95217] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2133), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1545), 2, + ACTIONS(2944), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1946), 1, + aux_sym_for_phrase_repeat1, + STATE(1981), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75837] = 13, - ACTIONS(373), 1, + [95250] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2135), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1546), 2, + ACTIONS(2944), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1982), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75884] = 13, - ACTIONS(373), 1, + [95283] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2137), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1547), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2946), 1, + sym__terminator, + STATE(1963), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1983), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [75931] = 13, - ACTIONS(373), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95316] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2139), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1548), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2948), 1, + sym__terminator, + STATE(1959), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1984), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95349] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(71), 1, + sym__namedot, + STATE(1985), 2, + sym_comment, + sym_include, + ACTIONS(69), 8, + sym_identifier, + sym__terminator, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [95376] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2950), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(1986), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [75978] = 13, - ACTIONS(373), 1, + [95409] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2141), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1549), 2, + ACTIONS(2682), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1992), 1, + aux_sym_for_phrase_repeat1, + STATE(1987), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76025] = 15, - ACTIONS(373), 1, + [95442] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2143), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1579), 1, - aux_sym_class_statement_repeat1, - STATE(1550), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2952), 1, + sym__terminator, + STATE(1971), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1988), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [76076] = 13, - ACTIONS(373), 1, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95475] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2145), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1551), 2, + ACTIONS(2954), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1989), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76123] = 13, - ACTIONS(373), 1, + [95508] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2147), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1552), 2, + ACTIONS(2954), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(2010), 1, + aux_sym_for_phrase_repeat1, + STATE(1990), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76170] = 13, - ACTIONS(373), 1, + [95541] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2149), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1553), 2, + ACTIONS(2632), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(2002), 1, + aux_sym_for_phrase_repeat1, + STATE(1991), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76217] = 13, - ACTIONS(373), 1, + [95574] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2151), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1554), 2, + ACTIONS(2733), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(1992), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76264] = 13, - ACTIONS(373), 1, + [95607] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2153), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1555), 2, + STATE(2483), 1, + sym_sort_order, + STATE(1993), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2419), 4, + sym_identifier, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + ACTIONS(2652), 4, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + [95636] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2688), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(1969), 1, + aux_sym_for_phrase_repeat1, + STATE(1994), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76311] = 13, - ACTIONS(373), 1, + [95669] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2155), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1556), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2956), 1, + sym__terminator, + STATE(1997), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(1995), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95702] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2682), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(1996), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76358] = 13, - ACTIONS(373), 1, + [95735] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2157), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1557), 2, + ACTIONS(2958), 1, + sym__terminator, + ACTIONS(2963), 1, + aux_sym_variable_tuning_token6, + STATE(2058), 1, + sym_variable_tuning, + STATE(1997), 3, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + aux_sym_variable_definition_repeat2, + ACTIONS(2960), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [95766] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2688), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(1998), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76405] = 13, - ACTIONS(373), 1, + [95799] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2159), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1558), 2, + ACTIONS(2968), 1, + aux_sym_variable_definition_token2, + STATE(1999), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2966), 8, + aux_sym__block_terminator_token1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [95826] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2970), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(1986), 1, + aux_sym_for_phrase_repeat1, + STATE(2000), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76452] = 13, - ACTIONS(373), 1, + [95859] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2161), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1559), 2, + ACTIONS(2970), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(2001), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76499] = 12, - ACTIONS(373), 1, + [95892] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2163), 1, - anon_sym_RPAREN, - ACTIONS(2165), 1, - aux_sym_where_clause_token1, - ACTIONS(2171), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(2174), 1, - aux_sym_of_token1, - ACTIONS(2177), 1, - aux_sym__using_first_token1, - STATE(1576), 1, - sym__using_first, - STATE(1560), 3, + ACTIONS(2782), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(2002), 2, sym_comment, sym_include, - aux_sym_can_find_expression_repeat2, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(2168), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76544] = 13, - ACTIONS(373), 1, + [95925] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2180), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1561), 2, + ACTIONS(2974), 1, + aux_sym_variable_definition_token2, + STATE(2003), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2972), 8, + aux_sym__block_terminator_token1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [95952] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2733), 1, + sym__terminator, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(2001), 1, + aux_sym_for_phrase_repeat1, + STATE(2004), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76591] = 13, - ACTIONS(373), 1, + [95985] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2182), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1562), 2, + ACTIONS(2782), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1982), 1, + aux_sym_for_phrase_repeat1, + STATE(2005), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76638] = 13, - ACTIONS(373), 1, + [96018] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2184), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1563), 2, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2976), 1, + sym__terminator, + STATE(1964), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(2006), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [96051] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2885), 1, + aux_sym_variable_tuning_token6, + ACTIONS(2978), 1, + sym__terminator, + STATE(1965), 1, + aux_sym_variable_definition_repeat2, + STATE(2058), 1, + sym_variable_tuning, + STATE(2007), 2, + sym_comment, + sym_include, + ACTIONS(2883), 5, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + [96084] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(992), 1, + aux_sym_query_tuning_token6, + ACTIONS(2672), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, sym_query_tuning, - sym_of, - ACTIONS(932), 5, + STATE(2008), 2, + sym_comment, + sym_include, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76685] = 13, - ACTIONS(373), 1, + [96117] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2186), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1564), 2, + ACTIONS(2672), 1, + sym__terminator, + STATE(1795), 1, + sym_query_tuning, + STATE(1978), 1, + aux_sym_for_phrase_repeat1, + STATE(2009), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76732] = 13, - ACTIONS(373), 1, + [96150] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, + ACTIONS(992), 1, aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(938), 1, - aux_sym__using_first_token1, - ACTIONS(2188), 1, - anon_sym_RPAREN, - STATE(1560), 1, - aux_sym_can_find_expression_repeat2, - STATE(1576), 1, - sym__using_first, - STATE(1565), 2, + ACTIONS(2980), 1, + sym__terminator, + STATE(1694), 1, + aux_sym_for_phrase_repeat1, + STATE(1795), 1, + sym_query_tuning, + STATE(2010), 2, sym_comment, sym_include, - STATE(1708), 3, - sym_where_clause, - sym_query_tuning, - sym_of, - ACTIONS(932), 5, + ACTIONS(990), 5, aux_sym_query_tuning_token1, aux_sym_query_tuning_token2, aux_sym_query_tuning_token3, aux_sym_query_tuning_token4, aux_sym_query_tuning_token5, - [76779] = 10, - ACTIONS(3), 1, + [96183] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2192), 1, - anon_sym_LPAREN, - ACTIONS(2196), 1, + ACTIONS(2984), 1, + aux_sym_variable_definition_token2, + STATE(2011), 2, + sym_comment, + sym_include, + ACTIONS(2982), 8, + aux_sym__block_terminator_token1, + aux_sym_access_tuning_token1, + aux_sym_access_tuning_token2, + aux_sym_access_tuning_token3, + aux_sym_variable_definition_token1, + aux_sym_getter_token1, + aux_sym_setter_token1, + aux_sym_method_definition_token1, + [96210] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2130), 1, + sym_property_tuning, + ACTIONS(2988), 2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + STATE(2012), 3, + sym_comment, + sym_include, + aux_sym_property_definition_repeat1, + ACTIONS(2986), 4, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_property_definition_token1, + aux_sym_event_definition_token1, + [96238] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, sym__namedot, - STATE(1595), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2693), 1, + sym__terminator, + STATE(2), 1, aux_sym_qualified_name_repeat1, - STATE(1922), 1, - sym_sort_order, - STATE(1566), 2, + STATE(2165), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2013), 2, sym_comment, sym_include, - ACTIONS(2194), 4, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - ACTIONS(2190), 6, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96274] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2991), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2150), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2014), 2, + sym_comment, + sym_include, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96310] = 12, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(2993), 1, sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [76819] = 14, - ACTIONS(373), 1, + ACTIONS(2995), 1, + anon_sym_LBRACE, + ACTIONS(2997), 1, + anon_sym_RBRACE, + ACTIONS(2999), 1, + anon_sym_DQUOTE, + ACTIONS(3001), 1, + aux_sym_include_argument_token1, + STATE(2026), 1, + aux_sym_include_repeat1, + STATE(2445), 1, + sym_constant, + STATE(2446), 1, + sym_double_quoted_string, + STATE(2447), 1, + sym_include_argument, + STATE(2015), 2, + sym_comment, + sym_include, + [96348] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2111), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3003), 1, sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1591), 1, - sym_of, - STATE(1677), 1, - sym__pre_tuning, - STATE(1738), 1, - sym_where_clause, - STATE(1739), 1, - aux_sym_for_phrase_repeat1, - STATE(1567), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2177), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2016), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [76867] = 6, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96384] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2200), 1, - aux_sym_variable_definition_token4, - STATE(1568), 2, + ACTIONS(3005), 1, + sym__terminator, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3011), 1, + aux_sym_query_definition_token2, + ACTIONS(3013), 1, + aux_sym_query_definition_token3, + STATE(2107), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2017), 2, sym_comment, sym_include, - ACTIONS(2198), 13, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token1, - aux_sym_buffer_definition_token3, - aux_sym_query_definition_token1, - [76899] = 6, - ACTIONS(373), 1, + [96420] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(2642), 1, + sym_identifier, + STATE(2033), 1, + aux_sym_sort_clause_repeat1, + STATE(2468), 1, + sym_sort_column, + STATE(1993), 2, + sym_qualified_name, + sym_function_call, + STATE(2018), 2, + sym_comment, + sym_include, + ACTIONS(2648), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [96452] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2204), 1, - aux_sym_variable_definition_token4, - STATE(1569), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3015), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2112), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2019), 2, sym_comment, sym_include, - ACTIONS(2202), 13, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token1, - aux_sym_buffer_definition_token3, - aux_sym_query_definition_token1, - [76931] = 14, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96488] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2088), 1, - sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1601), 1, - sym_of, - STATE(1661), 1, - sym__pre_tuning, - STATE(1746), 1, - sym_where_clause, - STATE(1748), 1, - aux_sym_for_phrase_repeat1, - STATE(1570), 2, + ACTIONS(3017), 1, + sym_identifier, + STATE(1710), 1, + sym_qualified_name, + STATE(2947), 1, + sym__find_type, + STATE(2020), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [76979] = 8, - ACTIONS(373), 1, + ACTIONS(3019), 5, + aux_sym_on_error_phrase_token5, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + aux_sym__find_type_token1, + aux_sym__find_type_token2, + [96518] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2211), 1, - aux_sym_variable_definition_token4, - ACTIONS(2213), 2, - aux_sym_buffer_definition_token1, - aux_sym_query_definition_token1, - STATE(1571), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3021), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2136), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2021), 2, sym_comment, sym_include, - ACTIONS(2209), 4, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token3, - ACTIONS(2206), 7, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - [77015] = 14, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96554] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2115), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2638), 1, sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1603), 1, - sym_of, - STATE(1654), 1, - sym__pre_tuning, - STATE(1761), 1, - sym_where_clause, - STATE(1762), 1, - aux_sym_for_phrase_repeat1, - STATE(1572), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2213), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2022), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [77063] = 8, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96590] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2220), 1, - aux_sym_query_tuning_token6, - STATE(1597), 1, - sym_query_tuning, - STATE(1573), 3, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3023), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2174), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2023), 2, sym_comment, sym_include, - aux_sym_for_phrase_repeat1, - ACTIONS(2217), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - ACTIONS(2215), 6, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [77099] = 14, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96626] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(936), 1, - aux_sym_of_token1, - ACTIONS(2113), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3025), 1, sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1608), 1, - sym_of, - STATE(1618), 1, - sym__pre_tuning, - STATE(1765), 1, - sym_where_clause, - STATE(1769), 1, - aux_sym_for_phrase_repeat1, - STATE(1574), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2102), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2024), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [77147] = 5, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96662] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1575), 2, + ACTIONS(3027), 1, + sym_identifier, + STATE(1706), 1, + sym_qualified_name, + STATE(3027), 1, + sym__find_type, + STATE(2025), 2, sym_comment, sym_include, - ACTIONS(2223), 13, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [77176] = 8, - ACTIONS(373), 1, + ACTIONS(3019), 5, + aux_sym_on_error_phrase_token5, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + aux_sym__find_type_token1, + aux_sym__find_type_token2, + [96692] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(3029), 1, + sym_identifier, + ACTIONS(3032), 1, anon_sym_LBRACE, - ACTIONS(2227), 1, - aux_sym__using_and_token1, - STATE(1581), 1, - aux_sym_can_find_expression_repeat1, - STATE(1688), 1, - sym__using_and, - STATE(1576), 2, + ACTIONS(3035), 1, + anon_sym_RBRACE, + ACTIONS(3037), 1, + anon_sym_DQUOTE, + ACTIONS(3040), 1, + aux_sym_include_argument_token1, + STATE(2445), 1, + sym_constant, + STATE(2446), 1, + sym_double_quoted_string, + STATE(2447), 1, + sym_include_argument, + STATE(2026), 3, sym_comment, sym_include, - ACTIONS(2225), 10, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [77211] = 12, - ACTIONS(373), 1, + aux_sym_include_repeat1, + [96728] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2229), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2232), 1, - anon_sym_COLON, - ACTIONS(2234), 1, - aux_sym_class_statement_token2, - ACTIONS(2237), 1, - aux_sym_implements_token1, - ACTIONS(2240), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2243), 1, - aux_sym_abstract_token1, - ACTIONS(2246), 1, - aux_sym_final_token1, - STATE(1577), 3, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2674), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2114), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2027), 2, sym_comment, sym_include, - aux_sym_class_statement_repeat1, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77254] = 13, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [96764] = 12, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(2993), 1, + sym_identifier, + ACTIONS(2995), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2249), 1, - anon_sym_COLON, - STATE(1577), 1, - aux_sym_class_statement_repeat1, - STATE(1578), 2, + ACTIONS(2999), 1, + anon_sym_DQUOTE, + ACTIONS(3001), 1, + aux_sym_include_argument_token1, + ACTIONS(3043), 1, + anon_sym_RBRACE, + STATE(2015), 1, + aux_sym_include_repeat1, + STATE(2445), 1, + sym_constant, + STATE(2446), 1, + sym_double_quoted_string, + STATE(2447), 1, + sym_include_argument, + STATE(2028), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77299] = 13, - ACTIONS(373), 1, + [96802] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2251), 1, - anon_sym_COLON, - STATE(1577), 1, - aux_sym_class_statement_repeat1, - STATE(1579), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3045), 1, + sym__terminator, + ACTIONS(3047), 1, + aux_sym_query_definition_token2, + ACTIONS(3049), 1, + aux_sym_query_definition_token3, + STATE(2108), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2029), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77344] = 5, - ACTIONS(373), 1, + [96838] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1580), 2, + ACTIONS(2642), 1, + sym_identifier, + STATE(2033), 1, + aux_sym_sort_clause_repeat1, + STATE(2468), 1, + sym_sort_column, + STATE(1993), 2, + sym_qualified_name, + sym_function_call, + STATE(2030), 2, sym_comment, sym_include, - ACTIONS(2253), 13, + ACTIONS(3051), 3, sym__terminator, - anon_sym_LPAREN, - anon_sym_RPAREN, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - anon_sym_COMMA, - aux_sym_field_option_token1, aux_sym_field_definition_token1, aux_sym_index_definition_token1, - [77373] = 8, - ACTIONS(373), 1, + [96870] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2227), 1, - aux_sym__using_and_token1, - STATE(1582), 1, - aux_sym_can_find_expression_repeat1, - STATE(1688), 1, - sym__using_and, - STATE(1581), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3053), 1, + sym__terminator, + ACTIONS(3055), 1, + aux_sym_query_definition_token2, + ACTIONS(3057), 1, + aux_sym_query_definition_token3, + STATE(2129), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2031), 2, sym_comment, sym_include, - ACTIONS(2255), 10, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [77408] = 7, - ACTIONS(373), 1, + [96906] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2259), 1, - aux_sym__using_and_token1, - STATE(1688), 1, - sym__using_and, - STATE(1582), 3, + STATE(2218), 1, + sym_index_tuning, + ACTIONS(3061), 2, + aux_sym_variable_definition_token5, + aux_sym_index_tuning_token1, + STATE(2032), 3, sym_comment, sym_include, - aux_sym_can_find_expression_repeat1, - ACTIONS(2257), 10, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [77441] = 13, - ACTIONS(373), 1, + aux_sym_index_definition_repeat1, + ACTIONS(3059), 4, + sym_identifier, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [96934] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2262), 1, - anon_sym_COLON, - STATE(1577), 1, - aux_sym_class_statement_repeat1, - STATE(1583), 2, + ACTIONS(3064), 1, + sym_identifier, + STATE(2468), 1, + sym_sort_column, + STATE(1993), 2, + sym_qualified_name, + sym_function_call, + ACTIONS(2811), 3, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + STATE(2033), 3, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77486] = 13, - ACTIONS(373), 1, + aux_sym_sort_clause_repeat1, + [96964] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2264), 1, - anon_sym_COLON, - STATE(1577), 1, - aux_sym_class_statement_repeat1, - STATE(1584), 2, + STATE(2034), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77531] = 13, - ACTIONS(373), 1, + ACTIONS(436), 8, + sym_identifier, + sym__terminator, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [96988] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, - aux_sym_serialization_tuning_token1, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, - aux_sym_implements_token1, - ACTIONS(2127), 1, - aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, - aux_sym_final_token1, - ACTIONS(2143), 1, - anon_sym_COLON, - STATE(1578), 1, - aux_sym_class_statement_repeat1, - STATE(1585), 2, + STATE(2035), 2, sym_comment, sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77576] = 13, - ACTIONS(373), 1, + ACTIONS(432), 8, + sym_identifier, + sym__terminator, + aux_sym_sort_order_token1, + aux_sym_sort_order_token2, + aux_sym_sort_order_token3, + aux_sym_sort_order_token4, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [97012] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2119), 1, + STATE(2036), 2, + sym_comment, + sym_include, + ACTIONS(2835), 8, aux_sym_serialization_tuning_token1, - ACTIONS(2121), 1, + anon_sym_COMMA, anon_sym_COLON, - ACTIONS(2123), 1, - aux_sym_class_statement_token2, - ACTIONS(2125), 1, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, aux_sym_implements_token1, - ACTIONS(2127), 1, aux_sym_use_widget_pool_token1, - ACTIONS(2129), 1, - aux_sym_abstract_token1, - ACTIONS(2131), 1, aux_sym_final_token1, - STATE(1583), 1, - aux_sym_class_statement_repeat1, - STATE(1586), 2, - sym_comment, - sym_include, - STATE(1810), 5, - sym_implements, - sym_use_widget_pool, - sym_abstract, - sym_final, - sym_serializable, - [77621] = 12, - ACTIONS(373), 1, + [97036] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2268), 1, - aux_sym_variable_tuning_token1, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1668), 1, - aux_sym_field_definition_repeat1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2272), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - STATE(1587), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3067), 1, + sym__terminator, + ACTIONS(3069), 1, + aux_sym_query_definition_token2, + ACTIONS(3071), 1, + aux_sym_query_definition_token3, + STATE(2126), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2037), 2, sym_comment, sym_include, - ACTIONS(2266), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(2270), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - [77664] = 14, - ACTIONS(373), 1, + [97072] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2274), 1, - sym__terminator, - ACTIONS(2278), 1, - aux_sym_variable_definition_token6, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - STATE(1599), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1932), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1588), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1244), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2038), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [77710] = 14, - ACTIONS(373), 1, + [97107] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2280), 1, + ACTIONS(2897), 1, anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2286), 1, - sym__terminator, - ACTIONS(2288), 1, - aux_sym_variable_definition_token6, - STATE(1602), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1896), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1589), 2, + STATE(2039), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [77756] = 14, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2290), 1, + ACTIONS(2895), 6, sym__terminator, - ACTIONS(2292), 1, - aux_sym_variable_definition_token6, - STATE(1760), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1910), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, aux_sym_variable_tuning_token6, + aux_sym_variable_definition_token6, aux_sym_temp_table_tuning_token1, - STATE(1590), 2, - sym_comment, - sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [77802] = 12, - ACTIONS(373), 1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [97132] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2294), 1, - sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1676), 1, - sym__pre_tuning, - STATE(1716), 1, - aux_sym_for_phrase_repeat1, - STATE(1774), 1, - sym_where_clause, - STATE(1591), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3075), 1, + anon_sym_RPAREN, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + STATE(2572), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2040), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [77844] = 6, + [97165] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2296), 1, - sym__namedot, - STATE(1592), 3, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1305), 1, + sym_do_block, + STATE(2038), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2041), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 10, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [77874] = 12, + [97200] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2299), 1, + ACTIONS(1026), 1, sym_identifier, - STATE(1781), 1, - aux_sym_index_definition_repeat1, - STATE(1790), 1, - aux_sym_sort_clause_repeat1, - STATE(1854), 1, - sym_index_tuning, - STATE(2141), 1, - sym_sort_column, - ACTIONS(2303), 2, - aux_sym_variable_definition_token5, - aux_sym_index_tuning_token1, - STATE(1593), 2, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1305), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2042), 2, sym_comment, sym_include, - STATE(1729), 2, - sym_qualified_name, - sym_function_call, - ACTIONS(2301), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [77916] = 12, + [97235] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2299), 1, + ACTIONS(3073), 1, sym_identifier, - STATE(1593), 1, - aux_sym_index_definition_repeat1, - STATE(1792), 1, - aux_sym_sort_clause_repeat1, - STATE(1854), 1, - sym_index_tuning, - STATE(2141), 1, - sym_sort_column, - ACTIONS(2303), 2, - aux_sym_variable_definition_token5, - aux_sym_index_tuning_token1, - STATE(1594), 2, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3081), 1, + anon_sym_RPAREN, + STATE(2534), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2043), 2, sym_comment, sym_include, - STATE(1729), 2, - sym_qualified_name, - sym_function_call, - ACTIONS(2305), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [77958] = 7, + [97268] = 10, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2196), 1, - sym__namedot, - STATE(1592), 1, - aux_sym_qualified_name_repeat1, - STATE(1595), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3083), 1, + anon_sym_RPAREN, + STATE(2835), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2044), 2, sym_comment, sym_include, - ACTIONS(377), 10, - sym_identifier, - anon_sym_COMMA, + [97301] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3085), 1, anon_sym_COLON, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + STATE(2332), 1, + sym__while_condition, + STATE(2377), 1, + sym_on_error_phrase, + STATE(2715), 1, + sym_on_quit_phrase, + STATE(3401), 1, + sym_on_stop_phrase, + STATE(2045), 2, + sym_comment, + sym_include, + [97336] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [77990] = 6, - ACTIONS(373), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3089), 1, + anon_sym_COLON, + STATE(2321), 1, + sym__while_condition, + STATE(2389), 1, + sym_on_error_phrase, + STATE(2709), 1, + sym_on_quit_phrase, + STATE(3409), 1, + sym_on_stop_phrase, + STATE(2046), 2, + sym_comment, + sym_include, + [97371] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2309), 1, - aux_sym_variable_definition_token4, - STATE(1596), 2, + STATE(2047), 2, sym_comment, sym_include, - ACTIONS(2307), 11, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, + ACTIONS(3091), 7, aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token3, - [78020] = 5, - ACTIONS(373), 1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [97394] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1597), 2, + STATE(2048), 2, sym_comment, sym_include, - ACTIONS(2311), 12, - sym__terminator, - anon_sym_COMMA, + ACTIONS(3093), 7, + aux_sym_serialization_tuning_token1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [78048] = 10, - ACTIONS(373), 1, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [97417] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2313), 1, - aux_sym_buffer_definition_token1, - ACTIONS(2315), 1, - aux_sym_query_definition_token1, - STATE(1600), 1, - aux_sym_buffer_definition_repeat1, - STATE(1598), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3095), 1, + anon_sym_RPAREN, + STATE(2810), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2049), 2, sym_comment, sym_include, - STATE(1772), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [78086] = 14, - ACTIONS(373), 1, + [97450] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2317), 1, + STATE(2050), 2, + sym_comment, + sym_include, + ACTIONS(3097), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [97473] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2051), 2, + sym_comment, + sym_include, + ACTIONS(3099), 7, sym__terminator, - ACTIONS(2319), 1, - aux_sym_variable_definition_token6, - STATE(1760), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1859), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1599), 2, + [97496] = 9, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3101), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(1968), 2, + sym_qualified_name, + sym__string_literal, + STATE(2052), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [78132] = 8, - ACTIONS(373), 1, + [97527] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2327), 2, - aux_sym_buffer_definition_token1, - aux_sym_query_definition_token1, - STATE(1772), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(2324), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - STATE(1600), 3, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3103), 1, + anon_sym_RPAREN, + STATE(2901), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2053), 2, sym_comment, sym_include, - aux_sym_buffer_definition_repeat1, - ACTIONS(2321), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [78166] = 12, - ACTIONS(373), 1, + [97560] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2329), 1, - sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1615), 1, - sym__pre_tuning, - STATE(1763), 1, - aux_sym_for_phrase_repeat1, - STATE(1764), 1, - sym_where_clause, - STATE(1601), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3105), 1, + anon_sym_RPAREN, + STATE(2909), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2054), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [78208] = 14, - ACTIONS(373), 1, + [97593] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2274), 1, - sym__terminator, - ACTIONS(2278), 1, - aux_sym_variable_definition_token6, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - STATE(1760), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1932), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1602), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1421), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2055), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [78254] = 12, - ACTIONS(373), 1, + [97628] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2331), 1, - sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1692), 1, - sym__pre_tuning, - STATE(1734), 1, - aux_sym_for_phrase_repeat1, - STATE(1737), 1, - sym_where_clause, - STATE(1603), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1167), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2056), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [78296] = 10, - ACTIONS(373), 1, + [97663] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2333), 1, - aux_sym_buffer_definition_token1, - ACTIONS(2335), 1, - aux_sym_query_definition_token1, - STATE(1600), 1, - aux_sym_buffer_definition_repeat1, - STATE(1604), 2, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3107), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(1972), 2, + sym_qualified_name, + sym__string_literal, + STATE(2057), 2, sym_comment, sym_include, - STATE(1772), 2, - sym_scope_tuning, - sym_access_tuning, - ACTIONS(1454), 3, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - ACTIONS(1452), 4, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - [78334] = 6, - ACTIONS(373), 1, + [97694] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2058), 2, + sym_comment, + sym_include, + ACTIONS(3109), 7, + sym__terminator, + aux_sym_variable_tuning_token1, + aux_sym_variable_tuning_token2, + aux_sym_variable_tuning_token3, + aux_sym_variable_tuning_token4, + aux_sym_variable_tuning_token5, + aux_sym_variable_tuning_token6, + [97717] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2211), 1, - aux_sym_variable_definition_token4, - STATE(1605), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1244), 1, + sym_do_block, + STATE(2082), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2059), 2, sym_comment, sym_include, - ACTIONS(2209), 11, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - aux_sym_serialization_tuning_token1, - aux_sym_serialization_tuning_token2, - aux_sym_variable_definition_token3, - aux_sym_buffer_definition_token3, - [78364] = 14, - ACTIONS(373), 1, + [97752] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2337), 1, - sym__terminator, - ACTIONS(2339), 1, - aux_sym_variable_definition_token6, - STATE(1760), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1872), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1606), 2, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3111), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(2036), 2, + sym_qualified_name, + sym__string_literal, + STATE(2060), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [78410] = 14, - ACTIONS(373), 1, + [97783] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2290), 1, - sym__terminator, - ACTIONS(2292), 1, - aux_sym_variable_definition_token6, - STATE(1606), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1910), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1607), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1167), 1, + sym_do_block, + STATE(2092), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2061), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [78456] = 12, - ACTIONS(373), 1, + [97818] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2341), 1, - sym__terminator, - STATE(1575), 1, - sym_query_tuning, - STATE(1637), 1, - sym__pre_tuning, - STATE(1755), 1, - sym_where_clause, - STATE(1756), 1, - aux_sym_for_phrase_repeat1, - STATE(1608), 2, + ACTIONS(3113), 1, + aux_sym__block_terminator_token1, + ACTIONS(3115), 1, + aux_sym_case_when_branch_token1, + STATE(1164), 1, + sym__block_terminator, + STATE(1165), 1, + sym__case_terminator, + STATE(2100), 1, + aux_sym_case_body_repeat1, + STATE(2881), 1, + sym_case_when_branch, + STATE(2916), 1, + sym_case_body, + STATE(2062), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [78498] = 10, + [97853] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2343), 1, - anon_sym_LPAREN, - ACTIONS(2347), 1, - sym__namedot, - STATE(1702), 1, - aux_sym_qualified_name_repeat1, - STATE(2147), 1, - sym_sort_order, - STATE(1609), 2, - sym_comment, - sym_include, - ACTIONS(2190), 4, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3117), 1, sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(2345), 4, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - [78536] = 14, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2280), 1, - anon_sym_LIKE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2349), 1, - sym__terminator, - ACTIONS(2351), 1, - aux_sym_variable_definition_token6, - STATE(1590), 1, - aux_sym_temp_table_definition_repeat1, - STATE(1803), 1, - sym_temp_table_tuning, - STATE(1937), 1, - aux_sym_temp_table_definition_repeat2, - ACTIONS(2276), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1610), 2, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(2063), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [78582] = 15, - ACTIONS(373), 1, + STATE(2532), 2, + sym_qualified_name, + sym__string_literal, + [97884] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1978), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3119), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1904), 1, + STATE(2271), 1, + sym__while_condition, + STATE(2358), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1998), 1, + STATE(2633), 1, sym_on_quit_phrase, - STATE(2391), 1, + STATE(3544), 1, sym_on_stop_phrase, - STATE(2392), 1, - aux_sym_for_statement_repeat1, - STATE(1611), 2, + STATE(2064), 2, sym_comment, sym_include, - [78629] = 15, - ACTIONS(373), 1, + [97919] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1974), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1860), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2051), 1, - sym_on_quit_phrase, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(1612), 2, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3121), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(1700), 2, + sym_qualified_name, + sym__string_literal, + STATE(2065), 2, sym_comment, sym_include, - [78676] = 15, - ACTIONS(373), 1, + [97950] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2353), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3123), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1883), 1, + STATE(2280), 1, + sym__while_condition, + STATE(2414), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2017), 1, + STATE(2639), 1, sym_on_quit_phrase, - STATE(2474), 1, - aux_sym_for_statement_repeat1, - STATE(2482), 1, + STATE(3527), 1, sym_on_stop_phrase, - STATE(1613), 2, + STATE(2066), 2, sym_comment, sym_include, - [78723] = 5, - ACTIONS(373), 1, + [97985] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1614), 2, + STATE(2067), 2, sym_comment, sym_include, - ACTIONS(2355), 11, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym__using_and_token1, - [78750] = 11, - ACTIONS(373), 1, + ACTIONS(3125), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [98008] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2357), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1757), 1, - sym_where_clause, - STATE(1758), 1, - aux_sym_for_phrase_repeat1, - STATE(1615), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1268), 1, + sym_do_block, + STATE(2056), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2068), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [78789] = 15, - ACTIONS(373), 1, + [98043] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2018), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1933), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1967), 1, - sym_on_quit_phrase, - STATE(2193), 1, - sym_on_stop_phrase, - STATE(2196), 1, - aux_sym_for_statement_repeat1, - STATE(1616), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1182), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2069), 2, sym_comment, sym_include, - [78836] = 15, - ACTIONS(373), 1, + [98078] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3127), 1, + anon_sym_RPAREN, + STATE(2838), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2070), 2, + sym_comment, + sym_include, + [98111] = 11, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1982), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3129), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1892), 1, + STATE(2289), 1, + sym__while_condition, + STATE(2409), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2014), 1, + STATE(2877), 1, sym_on_quit_phrase, - STATE(2489), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 1, + STATE(3680), 1, sym_on_stop_phrase, - STATE(1617), 2, + STATE(2071), 2, sym_comment, sym_include, - [78883] = 11, - ACTIONS(373), 1, + [98146] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2341), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1755), 1, - sym_where_clause, - STATE(1756), 1, - aux_sym_for_phrase_repeat1, - STATE(1618), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1122), 1, + sym_do_block, + STATE(2069), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2072), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [78922] = 6, - ACTIONS(373), 1, + [98181] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(444), 1, - sym_accumulate_aggregate, - STATE(1619), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1122), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2073), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [78951] = 5, - ACTIONS(373), 1, + [98216] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1620), 2, + ACTIONS(3133), 1, + aux_sym_sort_clause_token1, + ACTIONS(3136), 1, + aux_sym_sort_clause_token2, + STATE(2227), 1, + sym_sort_clause, + ACTIONS(3131), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + STATE(2074), 3, sym_comment, sym_include, - ACTIONS(2361), 11, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym__using_and_token1, - [78978] = 6, - ACTIONS(373), 1, + aux_sym_for_phrase_repeat2, + [98245] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(494), 1, - sym_accumulate_aggregate, - STATE(1621), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1451), 1, + sym_do_block, + STATE(2055), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2075), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [79007] = 6, - ACTIONS(373), 1, + [98280] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(423), 1, - sym_accumulate_aggregate, - STATE(1622), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3139), 1, + sym__terminator, + ACTIONS(3141), 1, + aux_sym_query_definition_token3, + STATE(2117), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2076), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [79036] = 10, - ACTIONS(373), 1, + [98313] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2268), 1, - aux_sym_variable_tuning_token1, - STATE(1672), 1, - aux_sym_field_definition_repeat1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2272), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - STATE(1623), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3143), 1, + sym__terminator, + ACTIONS(3145), 1, + aux_sym_query_definition_token3, + STATE(2221), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2077), 2, + sym_comment, + sym_include, + [98346] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2078), 2, sym_comment, sym_include, - ACTIONS(2270), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - ACTIONS(2363), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [79073] = 10, - ACTIONS(373), 1, + ACTIONS(3147), 7, + aux_sym_serialization_tuning_token1, + anon_sym_COLON, + aux_sym_property_tuning_token1, + aux_sym_inherits_token1, + aux_sym_implements_token1, + aux_sym_use_widget_pool_token1, + aux_sym_final_token1, + [98369] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2268), 1, - aux_sym_variable_tuning_token1, - STATE(1668), 1, - aux_sym_field_definition_repeat1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2272), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - STATE(1624), 2, + ACTIONS(3115), 1, + aux_sym_case_when_branch_token1, + ACTIONS(3149), 1, + aux_sym__block_terminator_token1, + STATE(1449), 1, + sym__case_terminator, + STATE(1452), 1, + sym__block_terminator, + STATE(2100), 1, + aux_sym_case_body_repeat1, + STATE(2593), 1, + sym_case_body, + STATE(2881), 1, + sym_case_when_branch, + STATE(2079), 2, sym_comment, sym_include, - ACTIONS(2266), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(2270), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - [79110] = 15, - ACTIONS(373), 1, + [98404] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2022), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3151), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1877), 1, + STATE(2341), 1, + sym__while_condition, + STATE(2372), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2036), 1, + STATE(2786), 1, sym_on_quit_phrase, - STATE(2282), 1, + STATE(3496), 1, sym_on_stop_phrase, - STATE(2284), 1, - aux_sym_for_statement_repeat1, - STATE(1625), 2, + STATE(2080), 2, sym_comment, sym_include, - [79157] = 15, - ACTIONS(373), 1, + [98439] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1984), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1840), 1, - sym_on_error_phrase, - STATE(1957), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2333), 1, - sym_on_stop_phrase, - STATE(2418), 1, - aux_sym_for_statement_repeat1, - STATE(1626), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1159), 1, + sym_do_block, + STATE(2073), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2081), 2, sym_comment, sym_include, - [79204] = 6, - ACTIONS(373), 1, + [98474] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(499), 1, - sym_accumulate_aggregate, - STATE(1627), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1032), 1, + aux_sym_do_while_statement_token1, + STATE(1159), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3445), 1, + sym_label, + STATE(2082), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [79233] = 15, - ACTIONS(373), 1, + [98509] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2365), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1934), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1968), 1, - sym_on_quit_phrase, - STATE(2286), 1, - sym_on_stop_phrase, - STATE(2293), 1, - aux_sym_for_statement_repeat1, - STATE(1628), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1451), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2083), 2, sym_comment, sym_include, - [79280] = 15, - ACTIONS(373), 1, + [98544] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2006), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1900), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1988), 1, - sym_on_quit_phrase, - STATE(2200), 1, - sym_on_stop_phrase, - STATE(2224), 1, - aux_sym_for_statement_repeat1, - STATE(1629), 2, + ACTIONS(3155), 1, + anon_sym_LIKE, + STATE(2084), 2, sym_comment, sym_include, - [79327] = 6, - ACTIONS(373), 1, + ACTIONS(3153), 6, + sym__terminator, + aux_sym_variable_tuning_token6, + aux_sym_variable_definition_token6, + aux_sym_temp_table_tuning_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [98569] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2469), 1, - sym_accumulate_aggregate, - STATE(1630), 2, + ACTIONS(3159), 1, + anon_sym_LIKE, + STATE(2085), 2, sym_comment, sym_include, - ACTIONS(2367), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [79356] = 15, - ACTIONS(373), 1, + ACTIONS(3157), 6, + sym__terminator, + aux_sym_variable_tuning_token6, + aux_sym_variable_definition_token6, + aux_sym_temp_table_tuning_token1, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [98594] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1962), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1902), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2050), 1, - sym_on_quit_phrase, - STATE(2375), 1, - sym_on_stop_phrase, - STATE(2380), 1, - aux_sym_for_statement_repeat1, - STATE(1631), 2, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3161), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(1704), 2, + sym_qualified_name, + sym__string_literal, + STATE(2086), 2, sym_comment, sym_include, - [79403] = 15, - ACTIONS(373), 1, + [98625] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1966), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1942), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(1632), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1421), 1, + sym_do_block, + STATE(2090), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2087), 2, sym_comment, sym_include, - [79450] = 15, - ACTIONS(373), 1, + [98660] = 10, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1952), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1936), 1, - sym_on_error_phrase, - STATE(1956), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, - aux_sym_for_statement_repeat1, - STATE(1633), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + ACTIONS(3163), 1, + anon_sym_RPAREN, + STATE(2829), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2088), 2, sym_comment, sym_include, - [79497] = 15, - ACTIONS(373), 1, + [98693] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2014), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1849), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1972), 1, - sym_on_quit_phrase, - STATE(2409), 1, - aux_sym_for_statement_repeat1, - STATE(2411), 1, - sym_on_stop_phrase, - STATE(1634), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3165), 1, + sym__terminator, + ACTIONS(3167), 1, + aux_sym_query_definition_token3, + STATE(2111), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2089), 2, sym_comment, sym_include, - [79544] = 15, - ACTIONS(373), 1, + [98726] = 11, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2010), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1913), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1986), 1, - sym_on_quit_phrase, - STATE(2480), 1, - sym_on_stop_phrase, - STATE(2481), 1, - aux_sym_for_statement_repeat1, - STATE(1635), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1268), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2090), 2, sym_comment, sym_include, - [79591] = 15, - ACTIONS(373), 1, + [98761] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2040), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3169), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1903), 1, + STATE(2350), 1, + sym__while_condition, + STATE(2363), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2000), 1, + STATE(2781), 1, sym_on_quit_phrase, - STATE(2315), 1, + STATE(3485), 1, sym_on_stop_phrase, - STATE(2329), 1, - aux_sym_for_statement_repeat1, - STATE(1636), 2, - sym_comment, - sym_include, - [79638] = 11, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2369), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1726), 1, - sym_where_clause, - STATE(1727), 1, - aux_sym_for_phrase_repeat1, - STATE(1637), 2, + STATE(2091), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [79677] = 7, + [98796] = 11, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1922), 1, - sym_sort_order, - STATE(1638), 2, + ACTIONS(1026), 1, + sym_identifier, + ACTIONS(1028), 1, + aux_sym_input_expression_token2, + ACTIONS(1036), 1, + aux_sym_do_while_statement_token1, + STATE(1241), 1, + sym_do_block, + STATE(2258), 1, + aux_sym_on_statement_repeat2, + STATE(2812), 1, + sym_widget_phrase, + STATE(3511), 1, + sym_label, + STATE(2092), 2, sym_comment, sym_include, - ACTIONS(2194), 4, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - ACTIONS(2190), 6, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [79708] = 6, - ACTIONS(373), 1, + [98831] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(436), 1, - sym_accumulate_aggregate, - STATE(1639), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3171), 1, + sym__terminator, + ACTIONS(3173), 1, + aux_sym_query_definition_token3, + STATE(2134), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2093), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [79737] = 15, - ACTIONS(373), 1, + [98864] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1964), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3175), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1881), 1, + STATE(2270), 1, + sym__while_condition, + STATE(2420), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2070), 1, + STATE(2886), 1, sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, + STATE(3719), 1, sym_on_stop_phrase, - STATE(1640), 2, - sym_comment, - sym_include, - [79784] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(1641), 2, + STATE(2094), 2, sym_comment, sym_include, - ACTIONS(2371), 11, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym__using_and_token1, - [79811] = 15, - ACTIONS(373), 1, + [98899] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2373), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3177), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1899), 1, + STATE(2233), 1, + sym__while_condition, + STATE(2476), 1, sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2006), 1, + STATE(2770), 1, sym_on_quit_phrase, - STATE(2332), 1, + STATE(3460), 1, sym_on_stop_phrase, - STATE(2384), 1, - aux_sym_for_statement_repeat1, - STATE(1642), 2, + STATE(2095), 2, sym_comment, sym_include, - [79858] = 6, + [98934] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(387), 1, - sym__namedot, - STATE(1643), 2, + ACTIONS(136), 1, + anon_sym_DQUOTE, + ACTIONS(138), 1, + anon_sym_SQUOTE, + ACTIONS(3179), 1, + sym_identifier, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(2096), 2, sym_comment, sym_include, - ACTIONS(385), 10, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [79887] = 15, - ACTIONS(373), 1, + STATE(2906), 2, + sym_qualified_name, + sym__string_literal, + [98965] = 11, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2375), 1, + ACTIONS(3087), 1, + aux_sym__while_condition_token1, + ACTIONS(3181), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1938), 1, + STATE(2293), 1, + sym__while_condition, + STATE(2408), 1, sym_on_error_phrase, - STATE(1955), 1, + STATE(2911), 1, sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2257), 1, + STATE(3674), 1, sym_on_stop_phrase, - STATE(2285), 1, - aux_sym_for_statement_repeat1, - STATE(1644), 2, + STATE(2097), 2, sym_comment, sym_include, - [79934] = 15, - ACTIONS(373), 1, + [99000] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2377), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1891), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2033), 1, - sym_on_quit_phrase, - STATE(2515), 1, - sym_on_stop_phrase, - STATE(2516), 1, - aux_sym_for_statement_repeat1, - STATE(1645), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3003), 1, + sym__terminator, + STATE(2177), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2098), 2, sym_comment, sym_include, - [79981] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99030] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2379), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1940), 1, - sym_on_error_phrase, - STATE(1951), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2441), 1, - sym_on_stop_phrase, - STATE(2443), 1, - aux_sym_for_statement_repeat1, - STATE(1646), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2432), 1, + aux_sym_data_relation_repeat1, + STATE(3781), 1, + sym_data_relation, + STATE(2099), 2, sym_comment, sym_include, - [80028] = 15, - ACTIONS(373), 1, + [99062] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3115), 1, + aux_sym_case_when_branch_token1, + ACTIONS(3187), 1, + aux_sym__block_terminator_token1, + ACTIONS(3189), 1, + aux_sym_case_otherwise_branch_token1, + STATE(2224), 1, + aux_sym_case_body_repeat1, + STATE(2881), 1, + sym_case_when_branch, + STATE(3666), 1, + sym_case_otherwise_branch, + STATE(2100), 2, + sym_comment, + sym_include, + [99094] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1940), 1, + ACTIONS(3191), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1921), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1990), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2284), 1, sym_on_quit_phrase, - STATE(2209), 1, + STATE(2655), 1, sym_on_stop_phrase, - STATE(2298), 1, + STATE(2656), 1, aux_sym_for_statement_repeat1, - STATE(1647), 2, + STATE(2101), 2, sym_comment, sym_include, - [80075] = 9, - ACTIONS(373), 1, + [99126] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2383), 1, - aux_sym_variable_tuning_token1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2389), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - ACTIONS(2381), 3, - sym__terminator, + ACTIONS(2628), 1, aux_sym_field_definition_token1, + ACTIONS(2630), 1, aux_sym_index_definition_token1, - ACTIONS(2386), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - STATE(1648), 3, + ACTIONS(3015), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2102), 2, sym_comment, sym_include, - aux_sym_field_definition_repeat1, - [80110] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99156] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1968), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1941), 1, - sym_on_error_phrase, - STATE(1960), 1, - sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, - sym_on_stop_phrase, - STATE(1649), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3165), 1, + sym__terminator, + STATE(2111), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2103), 2, sym_comment, sym_include, - [80157] = 15, - ACTIONS(373), 1, + [99186] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1944), 1, + ACTIONS(3195), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1939), 1, - sym_on_error_phrase, - STATE(1958), 1, + STATE(2281), 1, sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2182), 1, + STATE(2649), 1, sym_on_stop_phrase, - STATE(2369), 1, + STATE(2650), 1, aux_sym_for_statement_repeat1, - STATE(1650), 2, + STATE(2104), 2, sym_comment, sym_include, - [80204] = 15, - ACTIONS(373), 1, + [99218] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1980), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1927), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1971), 1, - sym_on_quit_phrase, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, - sym_on_stop_phrase, - STATE(1651), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3021), 1, + sym__terminator, + STATE(2136), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2105), 2, sym_comment, sym_include, - [80251] = 6, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99248] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2207), 1, - sym_accumulate_aggregate, - STATE(1652), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3015), 1, + sym__terminator, + STATE(2112), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2106), 2, sym_comment, sym_include, - ACTIONS(2367), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [80280] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99278] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2392), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1884), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2024), 1, - sym_on_quit_phrase, - STATE(2267), 1, - sym_on_stop_phrase, - STATE(2269), 1, - aux_sym_for_statement_repeat1, - STATE(1653), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3197), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2107), 2, sym_comment, sym_include, - [80327] = 11, - ACTIONS(373), 1, + [99308] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2331), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3199), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1734), 1, - aux_sym_for_phrase_repeat1, - STATE(1737), 1, - sym_where_clause, - STATE(1654), 2, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2108), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [80366] = 15, - ACTIONS(373), 1, + [99338] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2004), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1857), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2060), 1, - sym_on_quit_phrase, - STATE(2321), 1, - aux_sym_for_statement_repeat1, - STATE(2337), 1, - sym_on_stop_phrase, - STATE(1655), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3025), 1, + sym__terminator, + STATE(2102), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2109), 2, sym_comment, sym_include, - [80413] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99368] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2000), 1, + ACTIONS(2162), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1890), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2021), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2285), 1, sym_on_quit_phrase, - STATE(2419), 1, + STATE(2658), 1, sym_on_stop_phrase, - STATE(2420), 1, + STATE(2659), 1, aux_sym_for_statement_repeat1, - STATE(1656), 2, + STATE(2110), 2, sym_comment, sym_include, - [80460] = 15, - ACTIONS(373), 1, + [99400] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2048), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1858), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2057), 1, - sym_on_quit_phrase, - STATE(2305), 1, - aux_sym_for_statement_repeat1, - STATE(2306), 1, - sym_on_stop_phrase, - STATE(1657), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3201), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2111), 2, sym_comment, sym_include, - [80507] = 15, - ACTIONS(373), 1, + [99430] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2050), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1866), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2045), 1, - sym_on_quit_phrase, - STATE(2530), 1, - aux_sym_for_statement_repeat1, - STATE(2553), 1, - sym_on_stop_phrase, - STATE(1658), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3203), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2112), 2, sym_comment, sym_include, - [80554] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99460] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2020), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1847), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2072), 1, - sym_on_quit_phrase, - STATE(2330), 1, - sym_on_stop_phrase, - STATE(2339), 1, - aux_sym_for_statement_repeat1, - STATE(1659), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3139), 1, + sym__terminator, + STATE(2117), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2113), 2, sym_comment, sym_include, - [80601] = 15, - ACTIONS(373), 1, + [99490] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1988), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1917), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1983), 1, - sym_on_quit_phrase, - STATE(2210), 1, - sym_on_stop_phrase, - STATE(2231), 1, - aux_sym_for_statement_repeat1, - STATE(1660), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3025), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2114), 2, + sym_comment, + sym_include, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [99520] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3205), 1, + sym__terminator, + STATE(2168), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2115), 2, + sym_comment, + sym_include, + [99550] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3207), 1, + sym__terminator, + STATE(2118), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2116), 2, + sym_comment, + sym_include, + [99580] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3209), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2117), 2, sym_comment, sym_include, - [80648] = 11, - ACTIONS(373), 1, + [99610] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2329), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3211), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1763), 1, - aux_sym_for_phrase_repeat1, - STATE(1764), 1, - sym_where_clause, - STATE(1661), 2, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2118), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [80687] = 6, - ACTIONS(373), 1, + [99640] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(394), 1, - sym_accumulate_aggregate, - STATE(1662), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3213), 1, + sym__terminator, + STATE(2121), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2119), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [80716] = 15, - ACTIONS(373), 1, + [99670] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2044), 1, + ACTIONS(2721), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1851), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2061), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2286), 1, sym_on_quit_phrase, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 1, + STATE(2660), 1, sym_on_stop_phrase, - STATE(1663), 2, + STATE(2661), 1, + aux_sym_for_statement_repeat1, + STATE(2120), 2, sym_comment, sym_include, - [80763] = 15, - ACTIONS(373), 1, + [99702] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3215), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2121), 2, + sym_comment, + sym_include, + [99732] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1960), 1, + ACTIONS(2168), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1895), 1, - sym_on_error_phrase, - STATE(1947), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2287), 1, sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, + STATE(2662), 1, sym_on_stop_phrase, - STATE(1664), 2, + STATE(2663), 1, + aux_sym_for_statement_repeat1, + STATE(2122), 2, sym_comment, sym_include, - [80810] = 15, - ACTIONS(373), 1, + [99764] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1976), 1, + ACTIONS(2160), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1898), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2065), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2288), 1, sym_on_quit_phrase, - STATE(2336), 1, + STATE(2664), 1, sym_on_stop_phrase, - STATE(2342), 1, + STATE(2665), 1, aux_sym_for_statement_repeat1, - STATE(1665), 2, + STATE(2123), 2, sym_comment, sym_include, - [80857] = 15, - ACTIONS(373), 1, + [99796] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1990), 1, + ACTIONS(2102), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1926), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2001), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2290), 1, sym_on_quit_phrase, - STATE(2237), 1, + STATE(2667), 1, sym_on_stop_phrase, - STATE(2276), 1, + STATE(2668), 1, aux_sym_for_statement_repeat1, - STATE(1666), 2, + STATE(2124), 2, sym_comment, sym_include, - [80904] = 15, - ACTIONS(373), 1, + [99828] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2038), 1, + ACTIONS(2118), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1852), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2046), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2292), 1, sym_on_quit_phrase, - STATE(2542), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 1, + STATE(2672), 1, sym_on_stop_phrase, - STATE(1667), 2, + STATE(2673), 1, + aux_sym_for_statement_repeat1, + STATE(2125), 2, sym_comment, sym_include, - [80951] = 10, - ACTIONS(373), 1, + [99860] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2268), 1, - aux_sym_variable_tuning_token1, - STATE(1648), 1, - aux_sym_field_definition_repeat1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2272), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - STATE(1668), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3217), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2126), 2, sym_comment, sym_include, - ACTIONS(2270), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - ACTIONS(2394), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [80988] = 15, - ACTIONS(373), 1, + [99890] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1948), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1839), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2075), 1, - sym_on_quit_phrase, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1669), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3171), 1, + sym__terminator, + STATE(2134), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2127), 2, sym_comment, sym_include, - [81035] = 15, - ACTIONS(373), 1, + [99920] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2042), 1, + ACTIONS(2144), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1862), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2062), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2345), 1, sym_on_quit_phrase, - STATE(2531), 1, + STATE(2735), 1, aux_sym_for_statement_repeat1, - STATE(2541), 1, + STATE(2745), 1, sym_on_stop_phrase, - STATE(1670), 2, + STATE(2128), 2, sym_comment, sym_include, - [81082] = 15, - ACTIONS(373), 1, + [99952] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2024), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1855), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2058), 1, - sym_on_quit_phrase, - STATE(2317), 1, - sym_on_stop_phrase, - STATE(2320), 1, - aux_sym_for_statement_repeat1, - STATE(1671), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3219), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2129), 2, sym_comment, sym_include, - [81129] = 10, - ACTIONS(373), 1, + [99982] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2268), 1, - aux_sym_variable_tuning_token1, - STATE(1648), 1, - aux_sym_field_definition_repeat1, - STATE(1733), 1, - sym_field_option, - ACTIONS(2272), 2, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - STATE(1672), 2, + STATE(2130), 2, sym_comment, sym_include, - ACTIONS(2270), 3, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - ACTIONS(2396), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [81166] = 15, - ACTIONS(373), 1, + ACTIONS(3221), 6, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + aux_sym_property_definition_token1, + aux_sym_event_definition_token1, + [100004] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1972), 1, + ACTIONS(2166), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1873), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2030), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2300), 1, sym_on_quit_phrase, - STATE(2434), 1, + STATE(2862), 1, aux_sym_for_statement_repeat1, - STATE(2435), 1, + STATE(2864), 1, sym_on_stop_phrase, - STATE(1673), 2, + STATE(2131), 2, sym_comment, sym_include, - [81213] = 15, - ACTIONS(373), 1, + [100036] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2016), 1, + ACTIONS(2058), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1945), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2011), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2295), 1, sym_on_quit_phrase, - STATE(2374), 1, + STATE(2674), 1, aux_sym_for_statement_repeat1, - STATE(2393), 1, + STATE(2675), 1, sym_on_stop_phrase, - STATE(1674), 2, + STATE(2132), 2, sym_comment, sym_include, - [81260] = 15, - ACTIONS(373), 1, + [100068] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2398), 1, + ACTIONS(2060), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1919), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1987), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2263), 1, sym_on_quit_phrase, - STATE(2388), 1, + STATE(2618), 1, aux_sym_for_statement_repeat1, - STATE(2394), 1, + STATE(2619), 1, sym_on_stop_phrase, - STATE(1675), 2, + STATE(2133), 2, sym_comment, sym_include, - [81307] = 11, - ACTIONS(373), 1, + [100100] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2400), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3223), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1728), 1, - aux_sym_for_phrase_repeat1, - STATE(1745), 1, - sym_where_clause, - STATE(1676), 2, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2134), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [81346] = 11, - ACTIONS(373), 1, + [100130] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2294), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2074), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2297), 1, + sym_on_quit_phrase, + STATE(2679), 1, + sym_on_stop_phrase, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(2135), 2, + sym_comment, + sym_include, + [100162] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3225), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1716), 1, - aux_sym_for_phrase_repeat1, - STATE(1774), 1, - sym_where_clause, - STATE(1677), 2, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2136), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [81385] = 15, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100192] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2012), 1, - anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1869), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2027), 1, - sym_on_quit_phrase, - STATE(2362), 1, - sym_on_stop_phrase, - STATE(2363), 1, - aux_sym_for_statement_repeat1, - STATE(1678), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2391), 1, + aux_sym_data_relation_repeat1, + STATE(3435), 1, + sym_data_relation, + STATE(2137), 2, sym_comment, sym_include, - [81432] = 15, - ACTIONS(373), 1, + [100224] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + STATE(2138), 2, + sym_comment, + sym_include, + ACTIONS(3227), 6, + aux_sym_serialization_tuning_token1, + aux_sym_serialization_tuning_token2, + aux_sym_property_tuning_token1, + aux_sym_property_tuning_token2, + aux_sym_property_definition_token1, + aux_sym_event_definition_token1, + [100246] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2402), 1, + ACTIONS(2086), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1870), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2042), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2256), 1, sym_on_quit_phrase, - STATE(2290), 1, + STATE(2604), 1, sym_on_stop_phrase, - STATE(2291), 1, + STATE(2611), 1, aux_sym_for_statement_repeat1, - STATE(1679), 2, + STATE(2139), 2, sym_comment, sym_include, - [81479] = 15, - ACTIONS(373), 1, + [100278] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2002), 1, + ACTIONS(2723), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1885), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2026), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2282), 1, sym_on_quit_phrase, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2356), 1, + STATE(2653), 1, sym_on_stop_phrase, - STATE(1680), 2, + STATE(2654), 1, + aux_sym_for_statement_repeat1, + STATE(2140), 2, sym_comment, sym_include, - [81526] = 15, - ACTIONS(373), 1, + [100310] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2046), 1, + ACTIONS(2062), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1912), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1981), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2308), 1, sym_on_quit_phrase, - STATE(2195), 1, + STATE(2691), 1, aux_sym_for_statement_repeat1, - STATE(2202), 1, + STATE(2693), 1, sym_on_stop_phrase, - STATE(1681), 2, + STATE(2141), 2, sym_comment, sym_include, - [81573] = 6, - ACTIONS(373), 1, + [100342] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2888), 1, - sym_accumulate_aggregate, - STATE(1682), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2678), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2142), 2, sym_comment, sym_include, - ACTIONS(2367), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [81602] = 6, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100372] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(384), 1, - sym_accumulate_aggregate, - STATE(1683), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3229), 1, + anon_sym_COLON, + STATE(2333), 1, + sym_on_quit_phrase, + STATE(2722), 1, + sym_on_stop_phrase, + STATE(2723), 1, + aux_sym_for_statement_repeat1, + STATE(2143), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [81631] = 5, - ACTIONS(373), 1, + [100404] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1684), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2709), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2336), 1, + sym_on_quit_phrase, + STATE(2726), 1, + sym_on_stop_phrase, + STATE(2727), 1, + aux_sym_for_statement_repeat1, + STATE(2144), 2, sym_comment, sym_include, - ACTIONS(2404), 11, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym__using_and_token1, - [81658] = 15, - ACTIONS(373), 1, + [100436] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1986), 1, + ACTIONS(2048), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1861), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(1995), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2254), 1, sym_on_quit_phrase, - STATE(2221), 1, + STATE(2598), 1, aux_sym_for_statement_repeat1, - STATE(2294), 1, + STATE(2599), 1, sym_on_stop_phrase, - STATE(1685), 2, + STATE(2145), 2, sym_comment, sym_include, - [81705] = 15, - ACTIONS(373), 1, + [100468] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2406), 1, + ACTIONS(2056), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1842), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2035), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2278), 1, sym_on_quit_phrase, - STATE(2400), 1, - aux_sym_for_statement_repeat1, - STATE(2437), 1, + STATE(2636), 1, sym_on_stop_phrase, - STATE(1686), 2, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(2146), 2, sym_comment, sym_include, - [81752] = 9, - ACTIONS(373), 1, + [100500] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(2410), 1, - anon_sym_COMMA, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1723), 1, - aux_sym_implements_repeat1, - STATE(1687), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2638), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2147), 2, sym_comment, sym_include, - ACTIONS(2408), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [81787] = 5, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100530] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1688), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2693), 1, + sym__terminator, + STATE(2165), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2148), 2, sym_comment, sym_include, - ACTIONS(2412), 11, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - aux_sym__using_and_token1, - [81814] = 6, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100560] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(489), 1, - sym_accumulate_aggregate, - STATE(1689), 2, + ACTIONS(3233), 1, + aux_sym_field_definition_token1, + STATE(2172), 1, + aux_sym_widget_phrase_repeat1, + STATE(2454), 1, + sym_widget_field, + STATE(2149), 2, sym_comment, sym_include, - ACTIONS(2359), 10, - aux_sym_accumulate_aggregate_token1, - aux_sym_accumulate_aggregate_token2, - aux_sym_accumulate_aggregate_token3, - aux_sym_accumulate_aggregate_token4, - aux_sym_accumulate_aggregate_token5, - aux_sym_accumulate_aggregate_token6, - aux_sym_accumulate_aggregate_token7, - aux_sym_accumulate_aggregate_token8, - aux_sym_accumulate_aggregate_token9, - aux_sym_accumulate_aggregate_token10, - [81843] = 15, - ACTIONS(373), 1, + ACTIONS(3231), 3, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + [100588] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3021), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2150), 2, + sym_comment, + sym_include, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100618] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(2008), 1, + ACTIONS(3235), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1863), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2055), 1, + STATE(2338), 1, sym_on_quit_phrase, - STATE(2308), 1, + STATE(2728), 1, sym_on_stop_phrase, - STATE(2310), 1, + STATE(2729), 1, aux_sym_for_statement_repeat1, - STATE(1690), 2, + STATE(2151), 2, sym_comment, sym_include, - [81890] = 15, - ACTIONS(373), 1, + [100650] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - ACTIONS(1946), 1, + ACTIONS(2122), 1, anon_sym_COLON, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1841), 1, - sym_on_error_phrase, - STATE(1948), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2339), 1, sym_on_quit_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, + STATE(2730), 1, sym_on_stop_phrase, - STATE(1691), 2, + STATE(2731), 1, + aux_sym_for_statement_repeat1, + STATE(2152), 2, sym_comment, sym_include, - [81937] = 11, - ACTIONS(373), 1, + [100682] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(930), 1, - aux_sym_where_clause_token1, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2414), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2693), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1770), 1, - aux_sym_for_phrase_repeat1, - STATE(1771), 1, - sym_where_clause, - STATE(1692), 2, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2153), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [81976] = 13, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100712] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2725), 1, + anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2013), 1, - sym_on_error_phrase, - STATE(2143), 1, + STATE(2340), 1, sym_on_quit_phrase, - STATE(2929), 1, + STATE(2732), 1, sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1693), 2, + STATE(2734), 1, + aux_sym_for_statement_repeat1, + STATE(2154), 2, sym_comment, sym_include, - [82018] = 9, - ACTIONS(3), 1, + [100744] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2416), 1, - sym_identifier, - STATE(1699), 1, - aux_sym_sort_clause_repeat1, - STATE(1894), 1, - sym_sort_column, - STATE(1638), 2, - sym_qualified_name, - sym_function_call, - STATE(1694), 2, - sym_comment, - sym_include, - ACTIONS(2418), 5, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2776), 1, anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [82052] = 10, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(856), 1, - sym__integer_literal, - ACTIONS(862), 1, - anon_sym_LPAREN, - ACTIONS(2420), 1, - sym_identifier, - STATE(804), 1, - sym__decimal_literal, - STATE(806), 1, - sym__unary_minus_expressions, - STATE(1695), 2, - sym_comment, - sym_include, - STATE(838), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82088] = 10, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(2422), 1, - sym_identifier, - STATE(284), 1, - sym__decimal_literal, - STATE(306), 1, - sym__unary_minus_expressions, - STATE(1696), 2, + STATE(2252), 1, + sym_on_quit_phrase, + STATE(2825), 1, + aux_sym_for_statement_repeat1, + STATE(2839), 1, + sym_on_stop_phrase, + STATE(2155), 2, sym_comment, sym_include, - STATE(315), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82124] = 13, - ACTIONS(373), 1, + [100776] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2124), 1, + anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(1976), 1, - sym_on_error_phrase, - STATE(2101), 1, + STATE(2343), 1, sym_on_quit_phrase, - STATE(2962), 1, + STATE(2737), 1, sym_on_stop_phrase, - ACTIONS(2066), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1697), 2, + STATE(2739), 1, + aux_sym_for_statement_repeat1, + STATE(2156), 2, sym_comment, sym_include, - [82166] = 13, - ACTIONS(373), 1, + [100808] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2729), 1, + anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1946), 1, - sym_on_error_phrase, - STATE(1962), 1, - sym_sort_clause, - STATE(2111), 1, + STATE(2248), 1, sym_on_quit_phrase, - STATE(2957), 1, + STATE(2827), 1, sym_on_stop_phrase, - ACTIONS(2068), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1698), 2, + STATE(2848), 1, + aux_sym_for_statement_repeat1, + STATE(2157), 2, sym_comment, sym_include, - [82208] = 8, - ACTIONS(3), 1, + [100840] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2424), 1, - sym_identifier, - STATE(1894), 1, - sym_sort_column, - STATE(1638), 2, - sym_qualified_name, - sym_function_call, - STATE(1699), 3, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2697), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2158), 2, sym_comment, sym_include, - aux_sym_sort_clause_repeat1, - ACTIONS(2427), 5, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [82240] = 10, - ACTIONS(3), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100870] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(109), 1, - sym__integer_literal, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(2429), 1, - sym_identifier, - STATE(284), 1, - sym__decimal_literal, - STATE(306), 1, - sym__unary_minus_expressions, - STATE(1700), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2126), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2344), 1, + sym_on_quit_phrase, + STATE(2743), 1, + sym_on_stop_phrase, + STATE(2744), 1, + aux_sym_for_statement_repeat1, + STATE(2159), 2, sym_comment, sym_include, - STATE(315), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82276] = 10, - ACTIONS(3), 1, + [100902] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(804), 1, - sym__integer_literal, - ACTIONS(810), 1, - anon_sym_LPAREN, - ACTIONS(2431), 1, - sym_identifier, - STATE(774), 1, - sym__unary_minus_expressions, - STATE(782), 1, - sym__decimal_literal, - STATE(1701), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2674), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2160), 2, sym_comment, sym_include, - STATE(775), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82312] = 7, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100932] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2347), 1, - sym__namedot, - STATE(1706), 1, - aux_sym_qualified_name_repeat1, - STATE(1702), 2, + STATE(2161), 2, sym_comment, sym_include, - ACTIONS(377), 8, + ACTIONS(3237), 6, sym_identifier, sym__terminator, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, + aux_sym_variable_definition_token5, aux_sym_field_definition_token1, + aux_sym_index_tuning_token1, aux_sym_index_definition_token1, - [82342] = 5, - ACTIONS(3), 1, + [100954] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1703), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2674), 1, + sym__terminator, + STATE(2114), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2162), 2, sym_comment, sym_include, - ACTIONS(448), 10, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [82368] = 12, - ACTIONS(3), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [100984] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2433), 1, - sym_identifier, - ACTIONS(2435), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2114), 1, anon_sym_COLON, - ACTIONS(2437), 1, - aux_sym__while_condition_token1, - ACTIONS(2439), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2441), 1, - aux_sym_transaction_statement_token1, - STATE(3277), 1, - sym__while_condition, - STATE(3278), 1, - sym_assignment, - STATE(1704), 2, - sym_comment, - sym_include, - STATE(3276), 3, - sym_on_error_phrase, - sym_on_stop_phrase, + STATE(2347), 1, sym_on_quit_phrase, - [82408] = 13, - ACTIONS(373), 1, + STATE(2747), 1, + sym_on_stop_phrase, + STATE(2749), 1, + aux_sym_for_statement_repeat1, + STATE(2163), 2, + sym_comment, + sym_include, + [101016] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2128), 1, + anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(1994), 1, - sym_on_error_phrase, - STATE(2118), 1, + STATE(2348), 1, sym_on_quit_phrase, - STATE(2954), 1, + STATE(2751), 1, sym_on_stop_phrase, - ACTIONS(2443), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1705), 2, + STATE(2752), 1, + aux_sym_for_statement_repeat1, + STATE(2164), 2, sym_comment, sym_include, - [82450] = 6, - ACTIONS(3), 1, + [101048] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2445), 1, - sym__namedot, - STATE(1706), 3, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3023), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2165), 2, sym_comment, sym_include, - aux_sym_qualified_name_repeat1, - ACTIONS(385), 8, - sym_identifier, - sym__terminator, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [101078] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2628), 1, aux_sym_field_definition_token1, + ACTIONS(2630), 1, aux_sym_index_definition_token1, - [82478] = 10, - ACTIONS(3), 1, + ACTIONS(3023), 1, + sym__terminator, + STATE(2174), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2166), 2, + sym_comment, + sym_include, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [101108] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(554), 1, - sym__integer_literal, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(2448), 1, - sym_identifier, - STATE(518), 1, - sym__decimal_literal, - STATE(524), 1, - sym__unary_minus_expressions, - STATE(1707), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2068), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2351), 1, + sym_on_quit_phrase, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(2167), 2, sym_comment, sym_include, - STATE(519), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82514] = 5, - ACTIONS(373), 1, + [101140] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1708), 2, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3239), 1, + sym__terminator, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2168), 2, sym_comment, sym_include, - ACTIONS(2450), 10, - anon_sym_RPAREN, - aux_sym_where_clause_token1, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - aux_sym_query_tuning_token6, - aux_sym_of_token1, - aux_sym__using_first_token1, - [82540] = 13, - ACTIONS(373), 1, + [101170] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3241), 1, + sym__terminator, + STATE(2220), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2169), 2, + sym_comment, + sym_include, + [101200] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2142), 1, + anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(1194), 1, - aux_sym_sort_clause_token1, - ACTIONS(1196), 1, - aux_sym_sort_clause_token2, - STATE(1829), 1, - aux_sym_for_phrase_repeat2, - STATE(1962), 1, - sym_sort_clause, - STATE(2041), 1, - sym_on_error_phrase, - STATE(2095), 1, + STATE(2250), 1, sym_on_quit_phrase, - STATE(2966), 1, + STATE(2596), 1, sym_on_stop_phrase, - ACTIONS(1996), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1709), 2, + STATE(2597), 1, + aux_sym_for_statement_repeat1, + STATE(2170), 2, sym_comment, sym_include, - [82582] = 7, - ACTIONS(373), 1, + [101232] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(1710), 2, - sym_comment, - sym_include, - ACTIONS(2452), 8, - aux_sym_serialization_tuning_token1, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2108), 1, anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [82612] = 9, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2352), 1, + sym_on_quit_phrase, + STATE(2759), 1, + sym_on_stop_phrase, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(2171), 2, + sym_comment, + sym_include, + [101264] = 8, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2416), 1, - sym_identifier, - STATE(1699), 1, - aux_sym_sort_clause_repeat1, - STATE(1894), 1, - sym_sort_column, - STATE(1638), 2, - sym_qualified_name, - sym_function_call, - STATE(1711), 2, + ACTIONS(3233), 1, + aux_sym_field_definition_token1, + STATE(2203), 1, + aux_sym_widget_phrase_repeat1, + STATE(2454), 1, + sym_widget_field, + STATE(2172), 2, sym_comment, sym_include, - ACTIONS(2454), 5, + ACTIONS(3243), 3, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + [101292] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2100), 1, anon_sym_COLON, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [82646] = 5, - ACTIONS(3), 1, + STATE(2249), 1, + sym_on_quit_phrase, + STATE(2594), 1, + sym_on_stop_phrase, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(2173), 2, + sym_comment, + sym_include, + [101324] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1712), 2, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3003), 1, + sym__terminator, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2174), 2, sym_comment, sym_include, - ACTIONS(460), 10, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [82672] = 10, - ACTIONS(3), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [101354] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(750), 1, - sym__integer_literal, - ACTIONS(756), 1, - anon_sym_LPAREN, - ACTIONS(2456), 1, - sym_identifier, - STATE(640), 1, - sym__decimal_literal, - STATE(657), 1, - sym__unary_minus_expressions, - STATE(1713), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2469), 1, + aux_sym_data_relation_repeat1, + STATE(3384), 1, + sym_data_relation, + STATE(2175), 2, sym_comment, sym_include, - STATE(658), 5, - sym_qualified_name, - sym_number_literal, - sym_parenthesized_expression, - sym_function_call, - sym_object_access, - [82708] = 12, - ACTIONS(3), 1, + [101386] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2433), 1, - sym_identifier, - ACTIONS(2437), 1, - aux_sym__while_condition_token1, - ACTIONS(2439), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2458), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2050), 1, anon_sym_COLON, - ACTIONS(2460), 1, - aux_sym_transaction_statement_token1, - STATE(3236), 1, - sym_assignment, - STATE(3250), 1, - sym__while_condition, - STATE(1714), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2355), 1, + sym_on_quit_phrase, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(2176), 2, sym_comment, sym_include, - STATE(3248), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [82748] = 9, - ACTIONS(373), 1, + [101418] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2462), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(3245), 1, sym__terminator, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - STATE(1735), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1715), 2, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2177), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [82781] = 9, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [101448] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2400), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1716), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3247), 1, + anon_sym_COLON, + STATE(2335), 1, + sym_on_quit_phrase, + STATE(2796), 1, + sym_on_stop_phrase, + STATE(2797), 1, + aux_sym_for_statement_repeat1, + STATE(2178), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [82814] = 7, - ACTIONS(373), 1, + [101480] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2410), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(1723), 1, - aux_sym_implements_repeat1, - STATE(1717), 2, + ACTIONS(2760), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2331), 1, + sym_on_quit_phrase, + STATE(2800), 1, + sym_on_stop_phrase, + STATE(2801), 1, + aux_sym_for_statement_repeat1, + STATE(2179), 2, sym_comment, sym_include, - ACTIONS(2408), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [82843] = 7, - ACTIONS(373), 1, + [101512] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, + ACTIONS(67), 1, sym__namedot, - STATE(275), 1, + STATE(2), 1, aux_sym_qualified_name_repeat1, - STATE(1718), 2, + STATE(2180), 2, sym_comment, sym_include, - ACTIONS(2468), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [82872] = 9, - ACTIONS(373), 1, + ACTIONS(3249), 4, + anon_sym_RPAREN, + anon_sym_COMMA, + aux_sym_data_relation_token1, + aux_sym_data_relation_token2, + [101538] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2470), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1719), 2, + ACTIONS(3251), 1, + anon_sym_COMMA, + STATE(2181), 3, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [82905] = 9, - ACTIONS(373), 1, + aux_sym_on_statement_repeat1, + ACTIONS(1081), 4, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + aux_sym_widget_field_token1, + [101562] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2472), 1, - sym__terminator, - STATE(1753), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1720), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3254), 1, + anon_sym_COLON, + STATE(2329), 1, + sym_on_quit_phrase, + STATE(2803), 1, + sym_on_stop_phrase, + STATE(2804), 1, + aux_sym_for_statement_repeat1, + STATE(2182), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [82938] = 9, - ACTIONS(373), 1, + [101594] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2474), 1, - sym__terminator, - STATE(1759), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1721), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2104), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2319), 1, + sym_on_quit_phrase, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(2183), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [82971] = 9, - ACTIONS(373), 1, + [101626] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2476), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1722), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2134), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2327), 1, + sym_on_quit_phrase, + STATE(2805), 1, + sym_on_stop_phrase, + STATE(2806), 1, + aux_sym_for_statement_repeat1, + STATE(2184), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83004] = 7, - ACTIONS(373), 1, + [101658] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2410), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(1732), 1, - aux_sym_implements_repeat1, - STATE(1723), 2, + ACTIONS(2164), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2247), 1, + sym_on_quit_phrase, + STATE(2591), 1, + sym_on_stop_phrase, + STATE(2592), 1, + aux_sym_for_statement_repeat1, + STATE(2185), 2, sym_comment, sym_include, - ACTIONS(2478), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [83033] = 6, - ACTIONS(3), 1, + [101690] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(387), 1, - sym__namedot, - STATE(1724), 2, - sym_comment, - sym_include, - ACTIONS(385), 8, - sym_identifier, - sym__terminator, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, + ACTIONS(2628), 1, aux_sym_field_definition_token1, + ACTIONS(2630), 1, aux_sym_index_definition_token1, - [83060] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2480), 1, + ACTIONS(2668), 1, sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1725), 2, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2186), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83093] = 9, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [101720] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2482), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1740), 1, - aux_sym_for_phrase_repeat1, - STATE(1726), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2132), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2245), 1, + sym_on_quit_phrase, + STATE(2589), 1, + sym_on_stop_phrase, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(2187), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83126] = 9, - ACTIONS(373), 1, + [101752] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2482), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1727), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2764), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2326), 1, + sym_on_quit_phrase, + STATE(2807), 1, + sym_on_stop_phrase, + STATE(2808), 1, + aux_sym_for_statement_repeat1, + STATE(2188), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83159] = 9, - ACTIONS(373), 1, + [101784] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2484), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1728), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2136), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2324), 1, + sym_on_quit_phrase, + STATE(2813), 1, + sym_on_stop_phrase, + STATE(2814), 1, + aux_sym_for_statement_repeat1, + STATE(2189), 2, sym_comment, - sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83192] = 7, + sym_include, + [101816] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2147), 1, - sym_sort_order, - STATE(1729), 2, + STATE(2190), 2, sym_comment, sym_include, - ACTIONS(2190), 4, + ACTIONS(3256), 6, sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - ACTIONS(2345), 4, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - [83221] = 9, - ACTIONS(373), 1, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [101838] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2486), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1730), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2138), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2322), 1, + sym_on_quit_phrase, + STATE(2816), 1, + sym_on_stop_phrase, + STATE(2817), 1, + aux_sym_for_statement_repeat1, + STATE(2191), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83254] = 5, - ACTIONS(373), 1, + [101870] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1731), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2120), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2296), 1, + sym_on_quit_phrase, + STATE(2678), 1, + sym_on_stop_phrase, + STATE(2705), 1, + aux_sym_for_statement_repeat1, + STATE(2192), 2, sym_comment, sym_include, - ACTIONS(975), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [83279] = 6, - ACTIONS(373), 1, + [101902] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2488), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(1732), 3, + ACTIONS(2758), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2244), 1, + sym_on_quit_phrase, + STATE(2576), 1, + sym_on_stop_phrase, + STATE(2577), 1, + aux_sym_for_statement_repeat1, + STATE(2193), 2, sym_comment, sym_include, - aux_sym_implements_repeat1, - ACTIONS(2452), 7, - aux_sym_serialization_tuning_token1, + [101934] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2130), 1, anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [83306] = 5, - ACTIONS(373), 1, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2243), 1, + sym_on_quit_phrase, + STATE(2573), 1, + sym_on_stop_phrase, + STATE(2574), 1, + aux_sym_for_statement_repeat1, + STATE(2194), 2, + sym_comment, + sym_include, + [101966] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1733), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2110), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2320), 1, + sym_on_quit_phrase, + STATE(2820), 1, + sym_on_stop_phrase, + STATE(2821), 1, + aux_sym_for_statement_repeat1, + STATE(2195), 2, sym_comment, sym_include, - ACTIONS(2491), 9, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_field_option_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [83331] = 9, - ACTIONS(373), 1, + [101998] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2414), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1734), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3258), 1, + anon_sym_COLON, + STATE(2241), 1, + sym_on_quit_phrase, + STATE(2561), 1, + sym_on_stop_phrase, + STATE(2564), 1, + aux_sym_for_statement_repeat1, + STATE(2196), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83364] = 9, - ACTIONS(373), 1, + [102030] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2493), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1735), 2, + STATE(2197), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83397] = 9, - ACTIONS(373), 1, + ACTIONS(3260), 6, + sym_identifier, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [102052] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2495), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1736), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2756), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2240), 1, + sym_on_quit_phrase, + STATE(2558), 1, + sym_on_stop_phrase, + STATE(2560), 1, + aux_sym_for_statement_repeat1, + STATE(2198), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83430] = 9, - ACTIONS(373), 1, + [102084] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2414), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1770), 1, - aux_sym_for_phrase_repeat1, - STATE(1737), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2106), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2312), 1, + sym_on_quit_phrase, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 1, + sym_on_stop_phrase, + STATE(2199), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83463] = 9, - ACTIONS(373), 1, + [102116] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2294), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1716), 1, - aux_sym_for_phrase_repeat1, - STATE(1738), 2, + STATE(2200), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83496] = 9, - ACTIONS(373), 1, + ACTIONS(3262), 6, + sym_identifier, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [102138] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2294), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1739), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3264), 1, + anon_sym_COLON, + STATE(2239), 1, + sym_on_quit_phrase, + STATE(2551), 1, + sym_on_stop_phrase, + STATE(2552), 1, + aux_sym_for_statement_repeat1, + STATE(2201), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83529] = 9, - ACTIONS(373), 1, + [102170] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2497), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1740), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2140), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2318), 1, + sym_on_quit_phrase, + STATE(2830), 1, + sym_on_stop_phrase, + STATE(2831), 1, + aux_sym_for_statement_repeat1, + STATE(2202), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83562] = 9, - ACTIONS(373), 1, + [102202] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2499), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1741), 2, + ACTIONS(3266), 1, + sym_identifier, + ACTIONS(3271), 1, + aux_sym_field_definition_token1, + STATE(2454), 1, + sym_widget_field, + ACTIONS(3269), 2, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + STATE(2203), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83595] = 9, - ACTIONS(373), 1, + aux_sym_widget_phrase_repeat1, + [102230] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2501), 1, - sym__terminator, - STATE(1766), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1742), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2044), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2310), 1, + sym_on_quit_phrase, + STATE(2833), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(2204), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83628] = 9, - ACTIONS(373), 1, + [102262] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2503), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2638), 1, sym__terminator, - STATE(1719), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1743), 2, + STATE(2213), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2205), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83661] = 9, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [102292] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2505), 1, - sym__terminator, - STATE(1722), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1744), 2, + ACTIONS(3276), 1, + aux_sym_do_tuning_token1, + STATE(2427), 1, + sym_do_tuning, + ACTIONS(3274), 3, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_stop_after_phrase_token1, + STATE(2206), 3, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83694] = 9, - ACTIONS(373), 1, + aux_sym_do_block_repeat1, + [102318] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2484), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1752), 1, - aux_sym_for_phrase_repeat1, - STATE(1745), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2112), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2309), 1, + sym_on_quit_phrase, + STATE(2840), 1, + sym_on_stop_phrase, + STATE(2841), 1, + aux_sym_for_statement_repeat1, + STATE(2207), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83727] = 9, - ACTIONS(373), 1, + [102350] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2329), 1, + ACTIONS(3279), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1763), 1, - aux_sym_for_phrase_repeat1, - STATE(1746), 2, + ACTIONS(3281), 1, + aux_sym_query_definition_tuning_token1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3284), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2208), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83760] = 9, - ACTIONS(373), 1, + aux_sym_query_definition_repeat1, + [102378] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2507), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1747), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2042), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2242), 1, + sym_on_quit_phrase, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(2209), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83793] = 9, - ACTIONS(373), 1, + [102410] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2329), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1748), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2146), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2337), 1, + sym_on_quit_phrase, + STATE(2763), 1, + sym_on_stop_phrase, + STATE(2789), 1, + aux_sym_for_statement_repeat1, + STATE(2210), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83826] = 9, - ACTIONS(373), 1, + [102442] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2509), 1, + ACTIONS(3287), 1, sym__terminator, - STATE(1736), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1749), 2, + ACTIONS(3289), 1, + aux_sym_field_definition_token1, + ACTIONS(3292), 1, + aux_sym_index_definition_token1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + STATE(2211), 3, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83859] = 9, - ACTIONS(373), 1, + aux_sym_temp_table_definition_repeat2, + [102470] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2511), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3143), 1, sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1750), 2, + STATE(2221), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2212), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83892] = 9, - ACTIONS(373), 1, + [102500] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2513), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2991), 1, sym__terminator, - STATE(1725), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1751), 2, + STATE(2211), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2213), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83925] = 9, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [102530] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2515), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1752), 2, + ACTIONS(3073), 1, + sym_identifier, + ACTIONS(3079), 1, + aux_sym_function_parameter_token1, + STATE(3289), 1, + sym_function_parameter, + STATE(3292), 1, + sym_function_parameter_mode, + ACTIONS(3077), 2, + aux_sym_input_expression_token1, + aux_sym_argument_mode_token1, + STATE(2214), 2, + sym_comment, + sym_include, + [102560] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3295), 1, + anon_sym_COLON, + STATE(2229), 1, + sym_on_quit_phrase, + STATE(2541), 1, + sym_on_stop_phrase, + STATE(2569), 1, + aux_sym_for_statement_repeat1, + STATE(2215), 2, + sym_comment, + sym_include, + [102592] = 10, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2040), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2303), 1, + sym_on_quit_phrase, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, + sym_on_stop_phrase, + STATE(2216), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [83958] = 9, - ACTIONS(373), 1, + [102624] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2517), 1, + ACTIONS(2628), 1, + aux_sym_field_definition_token1, + ACTIONS(2630), 1, + aux_sym_index_definition_token1, + ACTIONS(2991), 1, sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1753), 2, + STATE(2150), 1, + aux_sym_temp_table_definition_repeat2, + STATE(2217), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [83991] = 8, - ACTIONS(373), 1, + STATE(2613), 2, + sym_field_definition, + sym_index_definition, + [102654] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2521), 1, - anon_sym_LIKE, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1754), 2, + STATE(2218), 2, sym_comment, sym_include, - ACTIONS(2519), 6, + ACTIONS(3297), 6, + sym_identifier, sym__terminator, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, + aux_sym_variable_definition_token5, aux_sym_field_definition_token1, + aux_sym_index_tuning_token1, aux_sym_index_definition_token1, - [84022] = 9, - ACTIONS(373), 1, + [102676] = 10, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2369), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1727), 1, - aux_sym_for_phrase_repeat1, - STATE(1755), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3299), 1, + anon_sym_COLON, + STATE(2275), 1, + sym_on_quit_phrase, + STATE(2884), 1, + sym_on_stop_phrase, + STATE(2885), 1, + aux_sym_for_statement_repeat1, + STATE(2219), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84055] = 9, - ACTIONS(373), 1, + [102708] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2369), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3301), 1, sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1756), 2, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2220), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84088] = 9, - ACTIONS(373), 1, + [102738] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2523), 1, + ACTIONS(3007), 1, + aux_sym_query_definition_tuning_token1, + ACTIONS(3303), 1, sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1730), 1, - aux_sym_for_phrase_repeat1, - STATE(1757), 2, + STATE(2208), 1, + aux_sym_query_definition_repeat1, + STATE(2401), 1, + sym_query_definition_tuning, + ACTIONS(3009), 2, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + STATE(2221), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84121] = 9, - ACTIONS(373), 1, + [102768] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2523), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1758), 2, + ACTIONS(3305), 1, + sym_identifier, + STATE(1892), 1, + aux_sym_sort_clause_repeat1, + STATE(2190), 1, + sym_sort_column, + STATE(1847), 2, + sym_qualified_name, + sym_function_call, + STATE(2222), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84154] = 9, - ACTIONS(373), 1, + [102795] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2525), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1759), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2050), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2768), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 1, + sym_on_stop_phrase, + STATE(2223), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [84187] = 8, - ACTIONS(373), 1, + [102824] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2532), 1, - anon_sym_LIKE, - STATE(1803), 1, - sym_temp_table_tuning, - ACTIONS(2529), 2, - aux_sym_variable_tuning_token6, - aux_sym_temp_table_tuning_token1, - STATE(1760), 3, + ACTIONS(3311), 1, + aux_sym_case_when_branch_token1, + STATE(2881), 1, + sym_case_when_branch, + ACTIONS(3309), 2, + aux_sym__block_terminator_token1, + aux_sym_case_otherwise_branch_token1, + STATE(2224), 3, sym_comment, sym_include, - aux_sym_temp_table_definition_repeat1, - ACTIONS(2527), 4, - sym__terminator, - aux_sym_variable_definition_token6, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [84218] = 9, - ACTIONS(373), 1, + aux_sym_case_body_repeat1, + [102849] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2331), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1734), 1, - aux_sym_for_phrase_repeat1, - STATE(1761), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2796), 1, + anon_sym_COLON, + STATE(2225), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84251] = 9, - ACTIONS(373), 1, + STATE(3589), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [102874] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2331), 1, + ACTIONS(3314), 1, + sym_identifier, + ACTIONS(3316), 1, sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1762), 2, + ACTIONS(3318), 1, + anon_sym_NO_DASHERROR, + STATE(2261), 1, + aux_sym_assign_statement_repeat1, + STATE(2918), 1, + sym_assignment, + STATE(2226), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84284] = 9, - ACTIONS(373), 1, + [102903] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2357), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1763), 2, + STATE(2227), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84317] = 9, - ACTIONS(373), 1, + ACTIONS(3320), 5, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + aux_sym_sort_clause_token1, + aux_sym_sort_clause_token2, + [102924] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2357), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1758), 1, - aux_sym_for_phrase_repeat1, - STATE(1764), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2056), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2636), 1, + sym_on_stop_phrase, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(2228), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84350] = 9, - ACTIONS(373), 1, + [102953] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2341), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1756), 1, - aux_sym_for_phrase_repeat1, - STATE(1765), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3322), 1, + anon_sym_COLON, + STATE(2787), 1, + sym_on_stop_phrase, + STATE(2905), 1, + aux_sym_for_statement_repeat1, + STATE(2229), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84383] = 9, - ACTIONS(373), 1, + [102982] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2535), 1, - sym__terminator, - STATE(1773), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1766), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2042), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 1, + sym_on_stop_phrase, + STATE(2230), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [84416] = 9, - ACTIONS(373), 1, + [103011] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2537), 1, + ACTIONS(3314), 1, + sym_identifier, + ACTIONS(3324), 1, sym__terminator, - STATE(1747), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1767), 2, + ACTIONS(3326), 1, + anon_sym_NO_DASHERROR, + STATE(2246), 1, + aux_sym_assign_statement_repeat1, + STATE(2918), 1, + sym_assignment, + STATE(2231), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [84449] = 9, - ACTIONS(373), 1, + [103040] = 8, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2466), 1, - aux_sym_variable_tuning_token6, - ACTIONS(2539), 1, - sym__terminator, - STATE(1750), 1, - aux_sym_variable_definition_repeat2, - STATE(1811), 1, - sym_variable_tuning, - STATE(1768), 2, + ACTIONS(3305), 1, + sym_identifier, + STATE(1908), 1, + aux_sym_sort_clause_repeat1, + STATE(2190), 1, + sym_sort_column, + STATE(1847), 2, + sym_qualified_name, + sym_function_call, + STATE(2232), 2, sym_comment, sym_include, - ACTIONS(2464), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [84482] = 9, - ACTIONS(373), 1, + [103067] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2341), 1, - sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1769), 2, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3328), 1, + anon_sym_COLON, + STATE(2405), 1, + sym_on_error_phrase, + STATE(2671), 1, + sym_on_quit_phrase, + STATE(3461), 1, + sym_on_stop_phrase, + STATE(2233), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84515] = 9, - ACTIONS(373), 1, + [103096] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2541), 1, + ACTIONS(3330), 1, + sym_identifier, + STATE(2918), 1, + sym_assignment, + ACTIONS(3333), 2, sym__terminator, - STATE(1573), 1, - aux_sym_for_phrase_repeat1, - STATE(1597), 1, - sym_query_tuning, - STATE(1770), 2, + anon_sym_NO_DASHERROR, + STATE(2234), 3, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84548] = 9, - ACTIONS(373), 1, + aux_sym_assign_statement_repeat1, + [103121] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2541), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1741), 1, - aux_sym_for_phrase_repeat1, - STATE(1771), 2, + ACTIONS(3335), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3339), 1, + aux_sym_on_error_phrase_token8, + STATE(2235), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84581] = 5, - ACTIONS(373), 1, + ACTIONS(3337), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [103146] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1772), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(3341), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(3708), 1, + sym_inherits, + STATE(2236), 2, sym_comment, sym_include, - ACTIONS(2213), 9, - aux_sym_scope_tuning_token1, - aux_sym_scope_tuning_token2, - aux_sym_scope_tuning_token3, - aux_sym_scope_tuning_token4, - aux_sym_access_tuning_token1, - aux_sym_access_tuning_token2, - aux_sym_access_tuning_token3, - aux_sym_buffer_definition_token1, - aux_sym_query_definition_token1, - [84606] = 8, - ACTIONS(373), 1, + [103175] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2543), 1, - sym__terminator, - ACTIONS(2548), 1, - aux_sym_variable_tuning_token6, - STATE(1811), 1, - sym_variable_tuning, - STATE(1773), 3, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3343), 1, + anon_sym_COLON, + STATE(2237), 2, sym_comment, sym_include, - aux_sym_variable_definition_repeat2, - ACTIONS(2545), 5, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - [84637] = 9, - ACTIONS(373), 1, + STATE(3723), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [103200] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(934), 1, - aux_sym_query_tuning_token6, - ACTIONS(2400), 1, - sym__terminator, - STATE(1597), 1, - sym_query_tuning, - STATE(1728), 1, - aux_sym_for_phrase_repeat1, - STATE(1774), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2802), 1, + anon_sym_COLON, + STATE(2238), 2, sym_comment, sym_include, - ACTIONS(932), 5, - aux_sym_query_tuning_token1, - aux_sym_query_tuning_token2, - aux_sym_query_tuning_token3, - aux_sym_query_tuning_token4, - aux_sym_query_tuning_token5, - [84670] = 11, - ACTIONS(373), 1, + STATE(3726), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [103225] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2551), 1, - sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1850), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1775), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3345), 1, + anon_sym_COLON, + STATE(2547), 1, + sym_on_stop_phrase, + STATE(2548), 1, + aux_sym_for_statement_repeat1, + STATE(2239), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [84706] = 12, - ACTIONS(373), 1, + [103254] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(992), 1, - aux_sym_widget_field_token1, - STATE(1168), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(1953), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1776), 2, + ACTIONS(3264), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2551), 1, + sym_on_stop_phrase, + STATE(2552), 1, + aux_sym_for_statement_repeat1, + STATE(2240), 2, sym_comment, sym_include, - [84744] = 11, - ACTIONS(373), 1, + [103283] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2553), 1, - sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1875), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1777), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3347), 1, + anon_sym_COLON, + STATE(2554), 1, + sym_on_stop_phrase, + STATE(2555), 1, + aux_sym_for_statement_repeat1, + STATE(2241), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [84780] = 8, - ACTIONS(3), 1, + [103312] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2555), 1, - sym_identifier, - STATE(1570), 1, - sym_qualified_name, - STATE(2579), 1, - sym__find_type, - STATE(1778), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2106), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 1, + sym_on_stop_phrase, + STATE(2242), 2, sym_comment, sym_include, - ACTIONS(2557), 5, - aux_sym_on_error_phrase_token5, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - aux_sym__find_type_token1, - aux_sym__find_type_token2, - [84810] = 12, - ACTIONS(3), 1, + [103341] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(2559), 1, - sym_identifier, - ACTIONS(2561), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2563), 1, - anon_sym_RBRACE, - ACTIONS(2565), 1, - anon_sym_DQUOTE, - ACTIONS(2567), 1, - aux_sym_include_argument_token1, - STATE(1802), 1, - aux_sym_include_repeat1, - STATE(2151), 1, - sym_constant, - STATE(2154), 1, - sym_double_quoted_string, - STATE(2158), 1, - sym_include_argument, - STATE(1779), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2756), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2558), 1, + sym_on_stop_phrase, + STATE(2560), 1, + aux_sym_for_statement_repeat1, + STATE(2243), 2, sym_comment, sym_include, - [84848] = 12, - ACTIONS(373), 1, + [103370] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(990), 1, - aux_sym_widget_field_token1, - STATE(1085), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2022), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1780), 2, + ACTIONS(3258), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2561), 1, + sym_on_stop_phrase, + STATE(2564), 1, + aux_sym_for_statement_repeat1, + STATE(2244), 2, sym_comment, sym_include, - [84886] = 7, - ACTIONS(3), 1, + [103399] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1854), 1, - sym_index_tuning, - ACTIONS(2571), 2, - aux_sym_variable_definition_token5, - aux_sym_index_tuning_token1, - STATE(1781), 3, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2130), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2573), 1, + sym_on_stop_phrase, + STATE(2574), 1, + aux_sym_for_statement_repeat1, + STATE(2245), 2, sym_comment, sym_include, - aux_sym_index_definition_repeat1, - ACTIONS(2569), 4, - sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [84914] = 11, - ACTIONS(373), 1, + [103428] = 9, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2337), 1, + ACTIONS(3314), 1, + sym_identifier, + ACTIONS(3349), 1, sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1872), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1782), 2, + ACTIONS(3351), 1, + anon_sym_NO_DASHERROR, + STATE(2234), 1, + aux_sym_assign_statement_repeat1, + STATE(2918), 1, + sym_assignment, + STATE(2246), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [84950] = 11, - ACTIONS(373), 1, + [103457] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2574), 1, - sym__terminator, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2580), 1, - aux_sym_query_definition_token2, - ACTIONS(2582), 1, - aux_sym_query_definition_token3, - STATE(1868), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1783), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2758), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2576), 1, + sym_on_stop_phrase, + STATE(2577), 1, + aux_sym_for_statement_repeat1, + STATE(2247), 2, sym_comment, sym_include, - [84986] = 11, - ACTIONS(373), 1, + [103486] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2584), 1, - sym__terminator, - ACTIONS(2586), 1, - aux_sym_query_definition_token2, - ACTIONS(2588), 1, - aux_sym_query_definition_token3, - STATE(1845), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1784), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3295), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2541), 1, + sym_on_stop_phrase, + STATE(2569), 1, + aux_sym_for_statement_repeat1, + STATE(2248), 2, sym_comment, sym_include, - [85022] = 11, - ACTIONS(373), 1, + [103515] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2590), 1, - sym__terminator, - ACTIONS(2592), 1, - aux_sym_query_definition_token2, - ACTIONS(2594), 1, - aux_sym_query_definition_token3, - STATE(1915), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1785), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2132), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2589), 1, + sym_on_stop_phrase, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(2249), 2, sym_comment, sym_include, - [85058] = 12, - ACTIONS(373), 1, + [103544] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(998), 1, - aux_sym_widget_field_token1, - STATE(1308), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2052), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1786), 2, + ACTIONS(2164), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2591), 1, + sym_on_stop_phrase, + STATE(2592), 1, + aux_sym_for_statement_repeat1, + STATE(2250), 2, sym_comment, sym_include, - [85096] = 5, + [103573] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1787), 2, + ACTIONS(3355), 1, + aux_sym_widget_field_token1, + STATE(2251), 2, sym_comment, sym_include, - ACTIONS(460), 8, + ACTIONS(3353), 4, sym_identifier, - sym__terminator, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [85120] = 12, - ACTIONS(373), 1, + [103596] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2596), 1, - aux_sym_widget_field_token1, - STATE(1169), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2043), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1788), 2, + ACTIONS(3299), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2884), 1, + sym_on_stop_phrase, + STATE(2885), 1, + aux_sym_for_statement_repeat1, + STATE(2252), 2, sym_comment, sym_include, - [85158] = 11, - ACTIONS(373), 1, + [103625] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2598), 1, - sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1909), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1789), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2435), 1, + sym_on_quit_phrase, + STATE(3137), 1, + sym_on_stop_phrase, + ACTIONS(2182), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2253), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [85194] = 9, - ACTIONS(3), 1, + [103652] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2299), 1, - sym_identifier, - STATE(1800), 1, - aux_sym_sort_clause_repeat1, - STATE(2141), 1, - sym_sort_column, - STATE(1729), 2, - sym_qualified_name, - sym_function_call, - STATE(1790), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2100), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2594), 1, + sym_on_stop_phrase, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(2254), 2, sym_comment, sym_include, - ACTIONS(2600), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [85226] = 11, - ACTIONS(373), 1, + [103681] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2317), 1, - sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1859), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1791), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2413), 1, + sym_on_quit_phrase, + STATE(3022), 1, + sym_on_stop_phrase, + ACTIONS(2869), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2255), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [85262] = 9, - ACTIONS(3), 1, + [103708] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2299), 1, - sym_identifier, - STATE(1800), 1, - aux_sym_sort_clause_repeat1, - STATE(2141), 1, - sym_sort_column, - STATE(1729), 2, - sym_qualified_name, - sym_function_call, - STATE(1792), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2142), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2596), 1, + sym_on_stop_phrase, + STATE(2597), 1, + aux_sym_for_statement_repeat1, + STATE(2256), 2, sym_comment, sym_include, - ACTIONS(2301), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [85294] = 11, - ACTIONS(3), 1, + [103737] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(2602), 1, - sym_identifier, - ACTIONS(2605), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2608), 1, - anon_sym_RBRACE, - ACTIONS(2610), 1, - anon_sym_DQUOTE, - ACTIONS(2613), 1, - aux_sym_include_argument_token1, - STATE(2151), 1, - sym_constant, - STATE(2154), 1, - sym_double_quoted_string, - STATE(2158), 1, - sym_include_argument, - STATE(1793), 3, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3357), 1, + anon_sym_COLON, + STATE(2257), 2, sym_comment, sym_include, - aux_sym_include_repeat1, - [85330] = 11, - ACTIONS(373), 1, + STATE(3616), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [103762] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2616), 1, - sym__terminator, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(1888), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1794), 2, + ACTIONS(3361), 1, + aux_sym_input_expression_token2, + STATE(2812), 1, + sym_widget_phrase, + ACTIONS(3359), 2, + sym_identifier, + aux_sym_do_while_statement_token1, + STATE(2258), 3, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [85366] = 5, - ACTIONS(373), 1, + aux_sym_on_statement_repeat2, + [103787] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1795), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3364), 1, + aux_sym_data_relation_token2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2850), 1, + aux_sym_data_relation_repeat1, + STATE(2259), 2, sym_comment, sym_include, - ACTIONS(2452), 8, - aux_sym_serialization_tuning_token1, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [85390] = 12, - ACTIONS(373), 1, + [103816] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(996), 1, - aux_sym_widget_field_token1, - STATE(1351), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2076), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1796), 2, + ACTIONS(2048), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 1, + sym_on_stop_phrase, + STATE(2260), 2, sym_comment, sym_include, - [85428] = 8, + [103845] = 9, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2618), 1, + ACTIONS(3314), 1, sym_identifier, - STATE(1572), 1, - sym_qualified_name, - STATE(2568), 1, - sym__find_type, - STATE(1797), 2, + ACTIONS(3366), 1, + sym__terminator, + ACTIONS(3368), 1, + anon_sym_NO_DASHERROR, + STATE(2234), 1, + aux_sym_assign_statement_repeat1, + STATE(2918), 1, + sym_assignment, + STATE(2261), 2, sym_comment, sym_include, - ACTIONS(2557), 5, - aux_sym_on_error_phrase_token5, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - aux_sym__find_type_token1, - aux_sym__find_type_token2, - [85458] = 11, - ACTIONS(373), 1, + [103874] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2620), 1, + STATE(2262), 2, + sym_comment, + sym_include, + ACTIONS(3370), 5, sym__terminator, - ACTIONS(2622), 1, - aux_sym_query_definition_token2, - ACTIONS(2624), 1, - aux_sym_query_definition_token3, - STATE(1843), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, + aux_sym_query_definition_tuning_token1, anon_sym_SCROLLING, aux_sym_query_definition_tuning_token2, - STATE(1798), 2, + aux_sym_query_definition_token3, + [103895] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2086), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2604), 1, + sym_on_stop_phrase, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(2263), 2, sym_comment, sym_include, - [85494] = 5, - ACTIONS(3), 1, + [103924] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1799), 2, + ACTIONS(3372), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3376), 1, + aux_sym_on_error_phrase_token8, + STATE(2264), 2, sym_comment, sym_include, - ACTIONS(448), 8, - sym_identifier, - sym__terminator, - aux_sym_sort_order_token1, - aux_sym_sort_order_token2, - aux_sym_sort_order_token3, - aux_sym_sort_order_token4, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [85518] = 8, - ACTIONS(3), 1, + ACTIONS(3374), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [103949] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2626), 1, - sym_identifier, - STATE(2141), 1, - sym_sort_column, - STATE(1729), 2, - sym_qualified_name, - sym_function_call, - ACTIONS(2427), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - STATE(1800), 3, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2451), 1, + sym_on_quit_phrase, + STATE(3086), 1, + sym_on_stop_phrase, + ACTIONS(2186), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2265), 2, sym_comment, sym_include, - aux_sym_sort_clause_repeat1, - [85548] = 12, - ACTIONS(373), 1, + [103976] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - ACTIONS(2629), 1, - aux_sym_widget_field_token1, - STATE(1380), 1, - sym_do_block, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2007), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1801), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(3378), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(3388), 1, + sym_inherits, + STATE(2266), 2, sym_comment, sym_include, - [85586] = 12, - ACTIONS(3), 1, + [104005] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(2559), 1, - sym_identifier, - ACTIONS(2561), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2565), 1, - anon_sym_DQUOTE, - ACTIONS(2567), 1, - aux_sym_include_argument_token1, - ACTIONS(2631), 1, - anon_sym_RBRACE, - STATE(1793), 1, - aux_sym_include_repeat1, - STATE(2151), 1, - sym_constant, - STATE(2154), 1, - sym_double_quoted_string, - STATE(2158), 1, - sym_include_argument, - STATE(1802), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2839), 1, + anon_sym_COLON, + STATE(2267), 2, sym_comment, sym_include, - [85624] = 6, - ACTIONS(373), 1, + STATE(3585), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104030] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2635), 1, - anon_sym_LIKE, - STATE(1803), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2060), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 1, + sym_on_stop_phrase, + STATE(2268), 2, sym_comment, sym_include, - ACTIONS(2633), 6, - sym__terminator, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [85649] = 9, - ACTIONS(3), 1, + [104059] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(2637), 1, - sym_identifier, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1804), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2792), 1, + anon_sym_COLON, + STATE(2269), 2, sym_comment, sym_include, - STATE(1834), 2, - sym_qualified_name, - sym__string_literal, - [85680] = 11, - ACTIONS(373), 1, + STATE(3434), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104084] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2639), 1, + ACTIONS(3380), 1, anon_sym_COLON, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - STATE(2037), 1, - sym__while_condition, - STATE(2096), 1, + STATE(2415), 1, sym_on_error_phrase, - STATE(2520), 1, + STATE(2878), 1, sym_on_quit_phrase, - STATE(3222), 1, + STATE(3683), 1, sym_on_stop_phrase, - STATE(1805), 2, + STATE(2270), 2, sym_comment, sym_include, - [85715] = 11, - ACTIONS(373), 1, + [104113] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2643), 1, + ACTIONS(3382), 1, anon_sym_COLON, - STATE(1985), 1, - sym__while_condition, - STATE(2178), 1, + STATE(2436), 1, sym_on_error_phrase, - STATE(2212), 1, + STATE(2621), 1, sym_on_quit_phrase, - STATE(3119), 1, + STATE(3572), 1, sym_on_stop_phrase, - STATE(1806), 2, + STATE(2271), 2, sym_comment, sym_include, - [85750] = 5, - ACTIONS(373), 1, + [104142] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1807), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2843), 1, + anon_sym_COLON, + STATE(2272), 2, sym_comment, sym_include, - ACTIONS(2645), 7, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - [85773] = 11, - ACTIONS(373), 1, + STATE(3567), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104167] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2647), 1, + ACTIONS(2827), 1, anon_sym_COLON, - STATE(2005), 1, - sym__while_condition, - STATE(2156), 1, + STATE(2273), 2, + sym_comment, + sym_include, + STATE(3678), 3, sym_on_error_phrase, - STATE(2238), 1, - sym_on_quit_phrase, - STATE(3128), 1, sym_on_stop_phrase, - STATE(1808), 2, + sym_on_quit_phrase, + [104192] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3384), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3388), 1, + aux_sym_on_error_phrase_token8, + STATE(2274), 2, sym_comment, sym_include, - [85808] = 9, - ACTIONS(3), 1, + ACTIONS(3386), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [104217] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(2649), 1, - sym_identifier, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1585), 2, - sym_qualified_name, - sym__string_literal, - STATE(1809), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3390), 1, + anon_sym_COLON, + STATE(2779), 1, + sym_on_stop_phrase, + STATE(2780), 1, + aux_sym_for_statement_repeat1, + STATE(2275), 2, sym_comment, sym_include, - [85839] = 5, - ACTIONS(373), 1, + [104246] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1810), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2819), 1, + anon_sym_COLON, + STATE(2276), 2, sym_comment, sym_include, - ACTIONS(2651), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [85862] = 5, - ACTIONS(373), 1, + STATE(3638), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104271] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1811), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2858), 1, + anon_sym_COLON, + STATE(2277), 2, sym_comment, sym_include, - ACTIONS(2653), 7, - sym__terminator, - aux_sym_variable_tuning_token1, - aux_sym_variable_tuning_token2, - aux_sym_variable_tuning_token3, - aux_sym_variable_tuning_token4, - aux_sym_variable_tuning_token5, - aux_sym_variable_tuning_token6, - [85885] = 9, - ACTIONS(3), 1, + STATE(3546), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104296] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(2655), 1, - sym_identifier, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1586), 2, - sym_qualified_name, - sym__string_literal, - STATE(1812), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2104), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2880), 1, + sym_on_stop_phrase, + STATE(2278), 2, sym_comment, sym_include, - [85916] = 11, - ACTIONS(373), 1, + [104325] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2657), 1, - anon_sym_COLON, - STATE(2038), 1, - sym__while_condition, - STATE(2142), 1, - sym_on_error_phrase, - STATE(2288), 1, + STATE(2360), 1, sym_on_quit_phrase, - STATE(3035), 1, + STATE(3265), 1, sym_on_stop_phrase, - STATE(1813), 2, + ACTIONS(3392), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2279), 2, sym_comment, sym_include, - [85951] = 11, - ACTIONS(373), 1, + [104352] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2659), 1, - aux_sym__block_terminator_token1, - ACTIONS(2661), 1, - aux_sym_case_when_branch_token1, - STATE(1229), 1, - sym__block_terminator, - STATE(1230), 1, - sym__case_terminator, - STATE(1878), 1, - aux_sym_case_body_repeat1, - STATE(2279), 1, - sym_case_when_branch, - STATE(2295), 1, - sym_case_body, - STATE(1814), 2, + ACTIONS(1282), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3394), 1, + anon_sym_COLON, + STATE(2421), 1, + sym_on_error_phrase, + STATE(2634), 1, + sym_on_quit_phrase, + STATE(3542), 1, + sym_on_stop_phrase, + STATE(2280), 2, sym_comment, sym_include, - [85986] = 5, - ACTIONS(373), 1, + [104381] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1815), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3396), 1, + anon_sym_COLON, + STATE(2644), 1, + sym_on_stop_phrase, + STATE(2645), 1, + aux_sym_for_statement_repeat1, + STATE(2281), 2, sym_comment, sym_include, - ACTIONS(2663), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [86009] = 5, - ACTIONS(373), 1, + [104410] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1816), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3195), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2649), 1, + sym_on_stop_phrase, + STATE(2650), 1, + aux_sym_for_statement_repeat1, + STATE(2282), 2, sym_comment, sym_include, - ACTIONS(2665), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [86032] = 9, - ACTIONS(3), 1, + [104439] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(2667), 1, - sym_identifier, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1717), 2, - sym_qualified_name, - sym__string_literal, - STATE(1817), 2, + ACTIONS(3398), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3402), 1, + aux_sym_on_error_phrase_token8, + STATE(2283), 2, sym_comment, sym_include, - [86063] = 6, - ACTIONS(373), 1, + ACTIONS(3400), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [104464] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2671), 1, - anon_sym_LIKE, - STATE(1818), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3404), 1, + anon_sym_COLON, + STATE(2651), 1, + sym_on_stop_phrase, + STATE(2652), 1, + aux_sym_for_statement_repeat1, + STATE(2284), 2, sym_comment, sym_include, - ACTIONS(2669), 6, - sym__terminator, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [86088] = 11, - ACTIONS(373), 1, + [104493] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2673), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2723), 1, anon_sym_COLON, - STATE(2009), 1, - sym__while_condition, - STATE(2152), 1, - sym_on_error_phrase, - STATE(2235), 1, - sym_on_quit_phrase, - STATE(3000), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2653), 1, sym_on_stop_phrase, - STATE(1819), 2, + STATE(2654), 1, + aux_sym_for_statement_repeat1, + STATE(2285), 2, sym_comment, sym_include, - [86123] = 11, - ACTIONS(373), 1, + [104522] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2675), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3191), 1, anon_sym_COLON, - STATE(2044), 1, - sym__while_condition, - STATE(2078), 1, - sym_on_error_phrase, - STATE(2343), 1, - sym_on_quit_phrase, - STATE(3281), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2655), 1, sym_on_stop_phrase, - STATE(1820), 2, + STATE(2656), 1, + aux_sym_for_statement_repeat1, + STATE(2286), 2, sym_comment, sym_include, - [86158] = 5, - ACTIONS(373), 1, + [104551] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1821), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2162), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2658), 1, + sym_on_stop_phrase, + STATE(2659), 1, + aux_sym_for_statement_repeat1, + STATE(2287), 2, sym_comment, sym_include, - ACTIONS(2677), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [86181] = 11, - ACTIONS(373), 1, + [104580] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2679), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2721), 1, anon_sym_COLON, - STATE(2019), 1, - sym__while_condition, - STATE(2115), 1, - sym_on_error_phrase, - STATE(2319), 1, - sym_on_quit_phrase, - STATE(3049), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2660), 1, sym_on_stop_phrase, - STATE(1822), 2, + STATE(2661), 1, + aux_sym_for_statement_repeat1, + STATE(2288), 2, sym_comment, sym_include, - [86216] = 11, - ACTIONS(373), 1, + [104609] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2681), 1, + ACTIONS(3406), 1, anon_sym_COLON, - STATE(1999), 1, - sym__while_condition, - STATE(2135), 1, + STATE(2402), 1, sym_on_error_phrase, - STATE(2323), 1, + STATE(2855), 1, sym_on_quit_phrase, - STATE(3204), 1, + STATE(3626), 1, sym_on_stop_phrase, - STATE(1823), 2, + STATE(2289), 2, sym_comment, sym_include, - [86251] = 10, - ACTIONS(373), 1, + [104638] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2683), 1, - sym__terminator, - ACTIONS(2685), 1, - aux_sym_query_definition_token3, - STATE(1867), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1824), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2168), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2662), 1, + sym_on_stop_phrase, + STATE(2663), 1, + aux_sym_for_statement_repeat1, + STATE(2290), 2, sym_comment, sym_include, - [86284] = 11, - ACTIONS(373), 1, + [104667] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2661), 1, - aux_sym_case_when_branch_token1, - ACTIONS(2687), 1, - aux_sym__block_terminator_token1, - STATE(1247), 1, - sym__block_terminator, - STATE(1261), 1, - sym__case_terminator, - STATE(1878), 1, - aux_sym_case_body_repeat1, - STATE(2277), 1, - sym_case_body, - STATE(2279), 1, - sym_case_when_branch, - STATE(1825), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2393), 1, + sym_on_quit_phrase, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2291), 2, sym_comment, sym_include, - [86319] = 10, - ACTIONS(373), 1, + [104694] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2689), 1, - sym__terminator, - ACTIONS(2691), 1, - aux_sym_query_definition_token3, - STATE(1907), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1826), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2160), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2664), 1, + sym_on_stop_phrase, + STATE(2665), 1, + aux_sym_for_statement_repeat1, + STATE(2292), 2, sym_comment, sym_include, - [86352] = 11, - ACTIONS(373), 1, + [104723] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2693), 1, + ACTIONS(3408), 1, anon_sym_COLON, - STATE(1963), 1, - sym__while_condition, - STATE(2169), 1, + STATE(2461), 1, sym_on_error_phrase, - STATE(2192), 1, + STATE(2777), 1, sym_on_quit_phrase, - STATE(3013), 1, + STATE(3479), 1, sym_on_stop_phrase, - STATE(1827), 2, + STATE(2293), 2, sym_comment, sym_include, - [86387] = 6, - ACTIONS(373), 1, + [104752] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2521), 1, - anon_sym_LIKE, - STATE(1828), 2, + ACTIONS(3410), 1, + anon_sym_DQUOTE, + ACTIONS(3412), 1, + anon_sym_SQUOTE, + STATE(1952), 1, + sym__string_literal, + STATE(296), 2, + sym_double_quoted_string, + sym_single_quoted_string, + STATE(2294), 2, sym_comment, sym_include, - ACTIONS(2519), 6, - sym__terminator, - aux_sym_variable_tuning_token6, - aux_sym_variable_definition_token6, - aux_sym_temp_table_tuning_token1, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [86412] = 8, - ACTIONS(373), 1, + [104779] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2697), 1, - aux_sym_sort_clause_token1, - ACTIONS(2700), 1, - aux_sym_sort_clause_token2, - STATE(1962), 1, - sym_sort_clause, - ACTIONS(2695), 3, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2102), 1, anon_sym_COLON, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(1829), 3, + STATE(2667), 1, + sym_on_stop_phrase, + STATE(2668), 1, + aux_sym_for_statement_repeat1, + STATE(2295), 2, sym_comment, sym_include, - aux_sym_for_phrase_repeat2, - [86441] = 9, - ACTIONS(3), 1, + [104808] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(111), 1, - anon_sym_DQUOTE, - ACTIONS(113), 1, - anon_sym_SQUOTE, - ACTIONS(2703), 1, - sym_identifier, - STATE(282), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1795), 2, - sym_qualified_name, - sym__string_literal, - STATE(1830), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2144), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2735), 1, + aux_sym_for_statement_repeat1, + STATE(2745), 1, + sym_on_stop_phrase, + STATE(2296), 2, sym_comment, sym_include, - [86472] = 10, - ACTIONS(373), 1, + [104837] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2705), 1, - sym__terminator, - ACTIONS(2707), 1, - aux_sym_query_definition_token3, - STATE(1874), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1831), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2118), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2672), 1, + sym_on_stop_phrase, + STATE(2673), 1, + aux_sym_for_statement_repeat1, + STATE(2297), 2, sym_comment, sym_include, - [86505] = 11, - ACTIONS(373), 1, + [104866] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2641), 1, - aux_sym__while_condition_token1, - ACTIONS(2709), 1, + ACTIONS(3414), 1, anon_sym_COLON, - STATE(2064), 1, - sym__while_condition, - STATE(2090), 1, + STATE(2298), 2, + sym_comment, + sym_include, + STATE(3473), 3, sym_on_error_phrase, - STATE(2540), 1, + sym_on_stop_phrase, sym_on_quit_phrase, - STATE(3259), 1, + [104891] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2040), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2851), 1, + aux_sym_for_statement_repeat1, + STATE(2852), 1, sym_on_stop_phrase, - STATE(1832), 2, + STATE(2299), 2, sym_comment, sym_include, - [86540] = 6, - ACTIONS(373), 1, + [104920] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2711), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(1833), 3, + ACTIONS(2146), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2763), 1, + sym_on_stop_phrase, + STATE(2789), 1, + aux_sym_for_statement_repeat1, + STATE(2300), 2, sym_comment, sym_include, - aux_sym_on_statement_repeat1, - ACTIONS(1011), 5, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - aux_sym_of_token1, - aux_sym_widget_field_token1, - aux_sym_on_statement_token1, - [86565] = 5, - ACTIONS(373), 1, + [104949] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1834), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2804), 1, + anon_sym_COLON, + STATE(2301), 2, sym_comment, sym_include, - ACTIONS(2468), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [86588] = 10, - ACTIONS(373), 1, + STATE(3376), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [104974] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2302), 2, + sym_comment, + sym_include, + ACTIONS(3416), 5, + sym__terminator, + aux_sym_query_definition_tuning_token1, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + aux_sym_query_definition_token3, + [104995] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2714), 1, - sym__terminator, - ACTIONS(2716), 1, - aux_sym_query_definition_token3, - STATE(1889), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1835), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2112), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2840), 1, + sym_on_stop_phrase, + STATE(2841), 1, + aux_sym_for_statement_repeat1, + STATE(2303), 2, sym_comment, sym_include, - [86621] = 5, - ACTIONS(373), 1, + [105024] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1836), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2058), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2675), 1, + sym_on_stop_phrase, + STATE(2304), 2, sym_comment, sym_include, - ACTIONS(2718), 7, - aux_sym_serialization_tuning_token1, - anon_sym_COLON, - aux_sym_class_statement_token2, - aux_sym_implements_token1, - aux_sym_use_widget_pool_token1, - aux_sym_abstract_token1, - aux_sym_final_token1, - [86644] = 10, - ACTIONS(373), 1, + [105053] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1962), 1, + ACTIONS(2044), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2050), 1, - sym_on_quit_phrase, - STATE(2375), 1, - sym_on_stop_phrase, - STATE(2380), 1, + STATE(2833), 1, aux_sym_for_statement_repeat1, - STATE(1837), 2, + STATE(2834), 1, + sym_on_stop_phrase, + STATE(2305), 2, sym_comment, sym_include, - [86676] = 9, - ACTIONS(373), 1, + [105082] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2722), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1838), 2, + ACTIONS(3420), 1, + aux_sym_widget_field_token1, + STATE(2306), 2, sym_comment, sym_include, - [86706] = 10, - ACTIONS(373), 1, + ACTIONS(3418), 4, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + aux_sym_field_definition_token1, + [105105] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1974), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - STATE(2051), 1, - sym_on_quit_phrase, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(1839), 2, + ACTIONS(3422), 1, + anon_sym_COLON, + STATE(2307), 2, sym_comment, sym_include, - [86738] = 10, - ACTIONS(373), 1, + STATE(3549), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [105130] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2038), 1, + ACTIONS(2074), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2046), 1, - sym_on_quit_phrase, - STATE(2542), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 1, + STATE(2679), 1, sym_on_stop_phrase, - STATE(1840), 2, + STATE(2680), 1, + aux_sym_for_statement_repeat1, + STATE(2308), 2, sym_comment, sym_include, - [86770] = 10, - ACTIONS(373), 1, + [105159] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1988), 1, + ACTIONS(2140), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(1983), 1, - sym_on_quit_phrase, - STATE(2210), 1, + STATE(2830), 1, sym_on_stop_phrase, - STATE(2231), 1, + STATE(2831), 1, aux_sym_for_statement_repeat1, - STATE(1841), 2, + STATE(2309), 2, sym_comment, sym_include, - [86802] = 10, - ACTIONS(373), 1, + [105188] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2724), 1, + ACTIONS(2110), 1, anon_sym_COLON, - STATE(1965), 1, - sym_on_quit_phrase, - STATE(2426), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2820), 1, sym_on_stop_phrase, - STATE(2457), 1, + STATE(2821), 1, aux_sym_for_statement_repeat1, - STATE(1842), 2, + STATE(2310), 2, sym_comment, sym_include, - [86834] = 9, - ACTIONS(373), 1, + [105217] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2726), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1843), 2, + ACTIONS(3424), 1, + anon_sym_COMMA, + ACTIONS(3249), 3, + anon_sym_RPAREN, + aux_sym_data_relation_token1, + aux_sym_data_relation_token2, + STATE(2311), 3, sym_comment, sym_include, - [86864] = 9, - ACTIONS(373), 1, + aux_sym_data_relation_repeat1, + [105240] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2553), 1, - sym__terminator, - STATE(1875), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1844), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2166), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2862), 1, + aux_sym_for_statement_repeat1, + STATE(2864), 1, + sym_on_stop_phrase, + STATE(2312), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [86894] = 9, - ACTIONS(373), 1, + [105269] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2728), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1845), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2817), 1, + anon_sym_COLON, + STATE(2313), 2, sym_comment, sym_include, - [86924] = 9, - ACTIONS(373), 1, + STATE(3442), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [105294] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2705), 1, - sym__terminator, - STATE(1874), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1846), 2, + ACTIONS(3427), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3431), 1, + aux_sym_on_error_phrase_token8, + STATE(2314), 2, sym_comment, sym_include, - [86954] = 10, - ACTIONS(373), 1, + ACTIONS(3429), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [105319] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2018), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1967), 1, + STATE(2453), 1, sym_on_quit_phrase, - STATE(2193), 1, + STATE(3098), 1, sym_on_stop_phrase, - STATE(2196), 1, - aux_sym_for_statement_repeat1, - STATE(1847), 2, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2315), 2, sym_comment, sym_include, - [86986] = 10, - ACTIONS(373), 1, + [105346] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3433), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3437), 1, + aux_sym_on_error_phrase_token8, + STATE(2316), 2, + sym_comment, + sym_include, + ACTIONS(3435), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [105371] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1966), 1, + ACTIONS(2062), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2063), 1, - sym_on_quit_phrase, - STATE(2510), 1, + STATE(2691), 1, aux_sym_for_statement_repeat1, - STATE(2552), 1, + STATE(2693), 1, sym_on_stop_phrase, - STATE(1848), 2, + STATE(2317), 2, sym_comment, sym_include, - [87018] = 10, - ACTIONS(373), 1, + [105400] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2353), 1, + ACTIONS(2138), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2017), 1, - sym_on_quit_phrase, - STATE(2474), 1, - aux_sym_for_statement_repeat1, - STATE(2482), 1, + STATE(2816), 1, sym_on_stop_phrase, - STATE(1849), 2, + STATE(2817), 1, + aux_sym_for_statement_repeat1, + STATE(2318), 2, sym_comment, sym_include, - [87050] = 9, - ACTIONS(373), 1, + [105429] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2553), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1850), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2120), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2678), 1, + sym_on_stop_phrase, + STATE(2705), 1, + aux_sym_for_statement_repeat1, + STATE(2319), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87080] = 10, - ACTIONS(373), 1, + [105458] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2050), 1, + ACTIONS(2136), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2045), 1, - sym_on_quit_phrase, - STATE(2530), 1, - aux_sym_for_statement_repeat1, - STATE(2553), 1, + STATE(2813), 1, sym_on_stop_phrase, - STATE(1851), 2, + STATE(2814), 1, + aux_sym_for_statement_repeat1, + STATE(2320), 2, sym_comment, sym_include, - [87112] = 10, - ACTIONS(373), 1, + [105487] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2048), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - STATE(2057), 1, + ACTIONS(3439), 1, + anon_sym_COLON, + STATE(2394), 1, + sym_on_error_phrase, + STATE(2699), 1, sym_on_quit_phrase, - STATE(2305), 1, - aux_sym_for_statement_repeat1, - STATE(2306), 1, + STATE(3428), 1, sym_on_stop_phrase, - STATE(1852), 2, + STATE(2321), 2, sym_comment, sym_include, - [87144] = 9, - ACTIONS(373), 1, + [105516] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2598), 1, - sym__terminator, - STATE(1909), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1853), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2764), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2807), 1, + sym_on_stop_phrase, + STATE(2808), 1, + aux_sym_for_statement_repeat1, + STATE(2322), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87174] = 5, - ACTIONS(3), 1, + [105545] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1854), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2794), 1, + anon_sym_COLON, + STATE(2323), 2, sym_comment, sym_include, - ACTIONS(2730), 6, - sym_identifier, - sym__terminator, - aux_sym_variable_definition_token5, - aux_sym_field_definition_token1, - aux_sym_index_tuning_token1, - aux_sym_index_definition_token1, - [87196] = 10, - ACTIONS(373), 1, + STATE(3425), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [105570] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2402), 1, + ACTIONS(2134), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2042), 1, - sym_on_quit_phrase, - STATE(2290), 1, + STATE(2805), 1, sym_on_stop_phrase, - STATE(2291), 1, + STATE(2806), 1, aux_sym_for_statement_repeat1, - STATE(1855), 2, + STATE(2324), 2, sym_comment, sym_include, - [87228] = 9, - ACTIONS(3), 1, + [105599] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2732), 1, - sym_identifier, - ACTIONS(2734), 1, - anon_sym_RPAREN, - STATE(2281), 1, - sym_function_parameter, - STATE(3034), 1, - sym_function_parameter_mode, - ACTIONS(2736), 2, - aux_sym_input_expression_token1, - aux_sym_argument_mode_token1, - STATE(1856), 2, + ACTIONS(3427), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3431), 1, + aux_sym_on_error_phrase_token8, + STATE(2325), 2, sym_comment, sym_include, - [87258] = 10, - ACTIONS(373), 1, + ACTIONS(3441), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [105624] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2398), 1, + ACTIONS(3254), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(1987), 1, - sym_on_quit_phrase, - STATE(2388), 1, - aux_sym_for_statement_repeat1, - STATE(2394), 1, + STATE(2803), 1, sym_on_stop_phrase, - STATE(1857), 2, + STATE(2804), 1, + aux_sym_for_statement_repeat1, + STATE(2326), 2, sym_comment, sym_include, - [87290] = 10, - ACTIONS(373), 1, + [105653] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2377), 1, + ACTIONS(2760), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2033), 1, - sym_on_quit_phrase, - STATE(2515), 1, + STATE(2800), 1, sym_on_stop_phrase, - STATE(2516), 1, + STATE(2801), 1, aux_sym_for_statement_repeat1, - STATE(1858), 2, + STATE(2327), 2, sym_comment, sym_include, - [87322] = 9, - ACTIONS(373), 1, + [105682] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2598), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1859), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3443), 1, + anon_sym_RPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2495), 1, + aux_sym_data_relation_repeat1, + STATE(2328), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87352] = 10, - ACTIONS(373), 1, + [105711] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2000), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2021), 1, - sym_on_quit_phrase, - STATE(2419), 1, + ACTIONS(3445), 1, + anon_sym_COLON, + STATE(2798), 1, sym_on_stop_phrase, - STATE(2420), 1, + STATE(2799), 1, aux_sym_for_statement_repeat1, - STATE(1860), 2, + STATE(2329), 2, sym_comment, sym_include, - [87384] = 10, - ACTIONS(373), 1, + [105740] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2867), 1, + anon_sym_COLON, + STATE(2330), 2, + sym_comment, + sym_include, + STATE(3411), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [105765] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2002), 1, + ACTIONS(3247), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2026), 1, - sym_on_quit_phrase, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2356), 1, + STATE(2796), 1, sym_on_stop_phrase, - STATE(1861), 2, + STATE(2797), 1, + aux_sym_for_statement_repeat1, + STATE(2331), 2, sym_comment, sym_include, - [87416] = 10, - ACTIONS(373), 1, + [105794] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2375), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - STATE(1955), 1, + ACTIONS(3447), 1, + anon_sym_COLON, + STATE(2384), 1, + sym_on_error_phrase, + STATE(2710), 1, sym_on_quit_phrase, - STATE(2257), 1, + STATE(3408), 1, sym_on_stop_phrase, - STATE(2285), 1, - aux_sym_for_statement_repeat1, - STATE(1862), 2, + STATE(2332), 2, sym_comment, sym_include, - [87448] = 10, - ACTIONS(373), 1, + [105823] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2022), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2036), 1, - sym_on_quit_phrase, - STATE(2282), 1, + ACTIONS(3449), 1, + anon_sym_COLON, + STATE(2719), 1, sym_on_stop_phrase, - STATE(2284), 1, + STATE(2720), 1, aux_sym_for_statement_repeat1, - STATE(1863), 2, + STATE(2333), 2, sym_comment, sym_include, - [87480] = 9, - ACTIONS(373), 1, + [105852] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2738), 1, - sym__terminator, - STATE(1916), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1864), 2, + ACTIONS(3433), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(3437), 1, + aux_sym_on_error_phrase_token8, + STATE(2334), 2, sym_comment, sym_include, - [87510] = 8, - ACTIONS(3), 1, + ACTIONS(3451), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [105877] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2740), 1, - sym_identifier, - ACTIONS(2745), 1, - aux_sym_field_definition_token1, - STATE(2136), 1, - sym_widget_field, - ACTIONS(2743), 2, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - STATE(1865), 3, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3453), 1, + anon_sym_COLON, + STATE(2793), 1, + sym_on_stop_phrase, + STATE(2794), 1, + aux_sym_for_statement_repeat1, + STATE(2335), 2, sym_comment, sym_include, - aux_sym_widget_phrase_repeat1, - [87538] = 10, - ACTIONS(373), 1, + [105906] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2373), 1, + ACTIONS(3229), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2006), 1, - sym_on_quit_phrase, - STATE(2332), 1, + STATE(2722), 1, sym_on_stop_phrase, - STATE(2384), 1, + STATE(2723), 1, aux_sym_for_statement_repeat1, - STATE(1866), 2, + STATE(2336), 2, sym_comment, sym_include, - [87570] = 9, - ACTIONS(373), 1, + [105935] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2748), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1867), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2776), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2825), 1, + aux_sym_for_statement_repeat1, + STATE(2839), 1, + sym_on_stop_phrase, + STATE(2337), 2, sym_comment, sym_include, - [87600] = 9, - ACTIONS(373), 1, + [105964] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2750), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1868), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3455), 1, + anon_sym_COLON, + STATE(2724), 1, + sym_on_stop_phrase, + STATE(2725), 1, + aux_sym_for_statement_repeat1, + STATE(2338), 2, + sym_comment, + sym_include, + [105993] = 9, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2709), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2726), 1, + sym_on_stop_phrase, + STATE(2727), 1, + aux_sym_for_statement_repeat1, + STATE(2339), 2, sym_comment, sym_include, - [87630] = 10, - ACTIONS(373), 1, + [106022] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2024), 1, + ACTIONS(3235), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2058), 1, - sym_on_quit_phrase, - STATE(2317), 1, + STATE(2728), 1, sym_on_stop_phrase, - STATE(2320), 1, + STATE(2729), 1, aux_sym_for_statement_repeat1, - STATE(1869), 2, + STATE(2340), 2, sym_comment, sym_include, - [87662] = 10, - ACTIONS(373), 1, + [106051] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2752), 1, + ACTIONS(3457), 1, anon_sym_COLON, - STATE(2025), 1, + STATE(2368), 1, + sym_on_error_phrase, + STATE(2782), 1, sym_on_quit_phrase, - STATE(2272), 1, + STATE(3486), 1, sym_on_stop_phrase, - STATE(2274), 1, - aux_sym_for_statement_repeat1, - STATE(1870), 2, - sym_comment, - sym_include, - [87694] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2551), 1, - sym__terminator, - STATE(1850), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1871), 2, + STATE(2341), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87724] = 9, - ACTIONS(373), 1, + [106080] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2551), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1872), 2, + ACTIONS(2784), 1, + anon_sym_COLON, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + STATE(2342), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87754] = 10, - ACTIONS(373), 1, + STATE(3484), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [106105] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2044), 1, + ACTIONS(2122), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2061), 1, - sym_on_quit_phrase, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 1, + STATE(2730), 1, sym_on_stop_phrase, - STATE(1873), 2, + STATE(2731), 1, + aux_sym_for_statement_repeat1, + STATE(2343), 2, sym_comment, sym_include, - [87786] = 9, - ACTIONS(373), 1, + [106134] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2754), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1874), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2725), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2732), 1, + sym_on_stop_phrase, + STATE(2734), 1, + aux_sym_for_statement_repeat1, + STATE(2344), 2, sym_comment, sym_include, - [87816] = 9, - ACTIONS(373), 1, + [106163] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2756), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1875), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2729), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2827), 1, + sym_on_stop_phrase, + STATE(2848), 1, + aux_sym_for_statement_repeat1, + STATE(2345), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87846] = 9, - ACTIONS(373), 1, + [106192] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2616), 1, - sym__terminator, - STATE(1888), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1876), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3459), 1, + anon_sym_RPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2717), 1, + aux_sym_data_relation_repeat1, + STATE(2346), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [87876] = 10, - ACTIONS(373), 1, + [106221] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2392), 1, + ACTIONS(2124), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2024), 1, - sym_on_quit_phrase, - STATE(2267), 1, + STATE(2737), 1, sym_on_stop_phrase, - STATE(2269), 1, + STATE(2739), 1, aux_sym_for_statement_repeat1, - STATE(1877), 2, + STATE(2347), 2, sym_comment, sym_include, - [87908] = 10, - ACTIONS(373), 1, + [106250] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2661), 1, - aux_sym_case_when_branch_token1, - ACTIONS(2758), 1, - aux_sym__block_terminator_token1, - ACTIONS(2760), 1, - aux_sym_case_otherwise_branch_token1, - STATE(1949), 1, - aux_sym_case_body_repeat1, - STATE(2279), 1, - sym_case_when_branch, - STATE(3076), 1, - sym_case_otherwise_branch, - STATE(1878), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2126), 1, + anon_sym_COLON, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2743), 1, + sym_on_stop_phrase, + STATE(2744), 1, + aux_sym_for_statement_repeat1, + STATE(2348), 2, sym_comment, sym_include, - [87940] = 9, - ACTIONS(373), 1, + [106279] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2683), 1, - sym__terminator, - STATE(1867), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1879), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2833), 1, + anon_sym_COLON, + STATE(2349), 2, sym_comment, sym_include, - [87970] = 10, - ACTIONS(373), 1, + STATE(3468), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [106304] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1968), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(1282), 1, aux_sym_on_error_phrase_token1, - STATE(1960), 1, + ACTIONS(3461), 1, + anon_sym_COLON, + STATE(2357), 1, + sym_on_error_phrase, + STATE(2773), 1, sym_on_quit_phrase, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, + STATE(3463), 1, sym_on_stop_phrase, - STATE(1880), 2, + STATE(2350), 2, sym_comment, sym_include, - [88002] = 10, - ACTIONS(373), 1, + [106333] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1990), 1, + ACTIONS(2114), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2001), 1, - sym_on_quit_phrase, - STATE(2237), 1, + STATE(2747), 1, sym_on_stop_phrase, - STATE(2276), 1, + STATE(2749), 1, aux_sym_for_statement_repeat1, - STATE(1881), 2, + STATE(2351), 2, sym_comment, sym_include, - [88034] = 10, - ACTIONS(373), 1, + [106362] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1944), 1, + ACTIONS(2128), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(1958), 1, - sym_on_quit_phrase, - STATE(2182), 1, + STATE(2751), 1, sym_on_stop_phrase, - STATE(2369), 1, + STATE(2752), 1, aux_sym_for_statement_repeat1, - STATE(1882), 2, + STATE(2352), 2, sym_comment, sym_include, - [88066] = 10, - ACTIONS(373), 1, + [106391] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, + ACTIONS(2786), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2762), 1, + ACTIONS(3463), 1, anon_sym_COLON, - STATE(2066), 1, - sym_on_quit_phrase, - STATE(2521), 1, - aux_sym_for_statement_repeat1, - STATE(2528), 1, - sym_on_stop_phrase, - STATE(1883), 2, + STATE(2353), 2, sym_comment, sym_include, - [88098] = 10, - ACTIONS(373), 1, + STATE(3379), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [106416] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2764), 1, + ACTIONS(2068), 1, anon_sym_COLON, - STATE(2023), 1, - sym_on_quit_phrase, - STATE(2258), 1, - sym_on_stop_phrase, - STATE(2260), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(2756), 1, aux_sym_for_statement_repeat1, - STATE(1884), 2, + STATE(2757), 1, + sym_on_stop_phrase, + STATE(2354), 2, sym_comment, sym_include, - [88130] = 10, - ACTIONS(373), 1, + [106445] = 9, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2014), 1, + ACTIONS(2108), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(1972), 1, - sym_on_quit_phrase, - STATE(2409), 1, - aux_sym_for_statement_repeat1, - STATE(2411), 1, + STATE(2759), 1, sym_on_stop_phrase, - STATE(1885), 2, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(2355), 2, sym_comment, sym_include, - [88162] = 9, - ACTIONS(373), 1, + [106474] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2689), 1, - sym__terminator, - STATE(1907), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1886), 2, + ACTIONS(2786), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(2841), 1, + anon_sym_COLON, + STATE(2356), 2, sym_comment, sym_include, - [88192] = 9, - ACTIONS(3), 1, + STATE(3447), 3, + sym_on_error_phrase, + sym_on_stop_phrase, + sym_on_quit_phrase, + [106499] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2766), 1, - sym_identifier, - ACTIONS(2770), 1, - aux_sym_field_definition_token1, - STATE(1930), 1, - aux_sym_widget_phrase_repeat1, - STATE(2136), 1, - sym_widget_field, - ACTIONS(2768), 2, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - STATE(1887), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3465), 1, + anon_sym_COLON, + STATE(2761), 1, + sym_on_quit_phrase, + STATE(3440), 1, + sym_on_stop_phrase, + STATE(2357), 2, sym_comment, sym_include, - [88222] = 9, - ACTIONS(373), 1, + [106525] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2772), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1888), 2, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3467), 1, + anon_sym_COLON, + STATE(2620), 1, + sym_on_quit_phrase, + STATE(3566), 1, + sym_on_stop_phrase, + STATE(2358), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [88252] = 9, - ACTIONS(373), 1, + [106551] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2774), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1889), 2, + ACTIONS(3471), 1, + aux_sym_variable_definition_token2, + STATE(2359), 2, sym_comment, sym_include, - [88282] = 10, - ACTIONS(373), 1, + ACTIONS(3469), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [106573] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2040), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2000), 1, - sym_on_quit_phrase, - STATE(2315), 1, + STATE(3332), 1, sym_on_stop_phrase, - STATE(2329), 1, - aux_sym_for_statement_repeat1, - STATE(1890), 2, + ACTIONS(3473), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2360), 2, sym_comment, sym_include, - [88314] = 10, - ACTIONS(373), 1, + [106597] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2776), 1, - anon_sym_COLON, - STATE(1964), 1, - sym_on_quit_phrase, - STATE(2452), 1, - sym_on_stop_phrase, - STATE(2455), 1, - aux_sym_for_statement_repeat1, - STATE(1891), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2469), 1, + aux_sym_data_relation_repeat1, + STATE(3384), 1, + sym_data_relation, + STATE(2361), 2, sym_comment, sym_include, - [88346] = 10, - ACTIONS(373), 1, + [106623] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2020), 1, + STATE(2362), 2, + sym_comment, + sym_include, + ACTIONS(3475), 4, anon_sym_COLON, - ACTIONS(2720), 1, aux_sym_on_error_phrase_token1, - STATE(2072), 1, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + [106643] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3477), 1, + anon_sym_COLON, + STATE(2772), 1, sym_on_quit_phrase, - STATE(2330), 1, + STATE(3469), 1, sym_on_stop_phrase, - STATE(2339), 1, - aux_sym_for_statement_repeat1, - STATE(1892), 2, + STATE(2363), 2, sym_comment, sym_include, - [88378] = 8, - ACTIONS(373), 1, + [106669] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2778), 1, - sym__terminator, - ACTIONS(2780), 1, - aux_sym_query_definition_tuning_token1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2783), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1893), 3, + STATE(2364), 2, sym_comment, sym_include, - aux_sym_query_definition_repeat1, - [88406] = 5, + ACTIONS(3479), 4, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [106689] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(1894), 2, + ACTIONS(3481), 1, + sym_identifier, + STATE(2365), 2, sym_comment, sym_include, - ACTIONS(2786), 6, - sym_identifier, + ACTIONS(3483), 3, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [88428] = 10, - ACTIONS(373), 1, + [106711] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1976), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2065), 1, - sym_on_quit_phrase, - STATE(2336), 1, - sym_on_stop_phrase, - STATE(2342), 1, - aux_sym_for_statement_repeat1, - STATE(1895), 2, + ACTIONS(3487), 1, + aux_sym_variable_definition_token2, + STATE(2366), 2, sym_comment, sym_include, - [88460] = 9, - ACTIONS(373), 1, + ACTIONS(3485), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [106733] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2274), 1, - sym__terminator, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1896), 2, + ACTIONS(3489), 1, + aux_sym_stream_definition_token1, + ACTIONS(3491), 1, + aux_sym_input_close_statement_token1, + ACTIONS(3493), 1, + aux_sym_input_close_statement_token2, + ACTIONS(3495), 1, + aux_sym_input_stream_statement_token1, + STATE(2367), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [88490] = 9, + [106759] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3497), 1, + anon_sym_COLON, + STATE(2775), 1, + sym_on_quit_phrase, + STATE(3474), 1, + sym_on_stop_phrase, + STATE(2368), 2, + sym_comment, + sym_include, + [106785] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2732), 1, + ACTIONS(3499), 1, sym_identifier, - ACTIONS(2788), 1, - anon_sym_RPAREN, - STATE(2382), 1, - sym_function_parameter, - STATE(3034), 1, - sym_function_parameter_mode, - ACTIONS(2736), 2, - aux_sym_input_expression_token1, - aux_sym_argument_mode_token1, - STATE(1897), 2, + STATE(285), 1, + sym_qualified_name, + ACTIONS(3501), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2369), 2, sym_comment, sym_include, - [88520] = 10, - ACTIONS(373), 1, + [106809] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2008), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2055), 1, - sym_on_quit_phrase, - STATE(2308), 1, - sym_on_stop_phrase, - STATE(2310), 1, - aux_sym_for_statement_repeat1, - STATE(1898), 2, + ACTIONS(3503), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2370), 2, sym_comment, sym_include, - [88552] = 10, - ACTIONS(373), 1, + ACTIONS(3505), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [106831] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2790), 1, - anon_sym_COLON, - STATE(1982), 1, - sym_on_quit_phrase, - STATE(2297), 1, - sym_on_stop_phrase, - STATE(2299), 1, - aux_sym_for_statement_repeat1, - STATE(1899), 2, + STATE(2371), 2, sym_comment, sym_include, - [88584] = 10, - ACTIONS(373), 1, + ACTIONS(3507), 4, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [106851] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2042), 1, + ACTIONS(3169), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(2062), 1, + STATE(2781), 1, sym_on_quit_phrase, - STATE(2531), 1, - aux_sym_for_statement_repeat1, - STATE(2541), 1, + STATE(3485), 1, sym_on_stop_phrase, - STATE(1900), 2, - sym_comment, - sym_include, - [88616] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2714), 1, - sym__terminator, - STATE(1889), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1901), 2, + STATE(2372), 2, sym_comment, sym_include, - [88646] = 10, - ACTIONS(373), 1, + [106877] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1982), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2014), 1, - sym_on_quit_phrase, - STATE(2489), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 1, - sym_on_stop_phrase, - STATE(1902), 2, + ACTIONS(3511), 1, + aux_sym_variable_definition_token2, + STATE(2373), 2, sym_comment, sym_include, - [88678] = 10, - ACTIONS(373), 1, + ACTIONS(3509), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [106899] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2365), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1968), 1, - sym_on_quit_phrase, - STATE(2286), 1, - sym_on_stop_phrase, - STATE(2293), 1, - aux_sym_for_statement_repeat1, - STATE(1903), 2, + ACTIONS(1552), 1, + aux_sym_variable_definition_token2, + STATE(2374), 2, sym_comment, sym_include, - [88710] = 10, - ACTIONS(373), 1, + ACTIONS(1550), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [106921] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2012), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2027), 1, - sym_on_quit_phrase, - STATE(2362), 1, - sym_on_stop_phrase, - STATE(2363), 1, - aux_sym_for_statement_repeat1, - STATE(1904), 2, + ACTIONS(3513), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2375), 2, sym_comment, sym_include, - [88742] = 9, - ACTIONS(373), 1, + ACTIONS(3515), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [106943] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2792), 1, - sym__terminator, - STATE(1914), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1905), 2, + ACTIONS(3517), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2376), 2, sym_comment, sym_include, - [88772] = 10, - ACTIONS(373), 1, + ACTIONS(3519), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [106965] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1964), 1, + ACTIONS(3089), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(2070), 1, + STATE(2709), 1, sym_on_quit_phrase, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, + STATE(3409), 1, sym_on_stop_phrase, - STATE(1906), 2, + STATE(2377), 2, sym_comment, sym_include, - [88804] = 9, - ACTIONS(373), 1, + [106991] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2794), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1907), 2, + STATE(2378), 2, sym_comment, sym_include, - [88834] = 10, - ACTIONS(373), 1, + ACTIONS(3521), 4, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [107011] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3523), 1, + sym_identifier, + STATE(2379), 2, + sym_comment, + sym_include, + ACTIONS(3525), 3, anon_sym_COMMA, - ACTIONS(1948), 1, anon_sym_COLON, - ACTIONS(2720), 1, aux_sym_on_error_phrase_token1, - STATE(2075), 1, - sym_on_quit_phrase, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1908), 2, - sym_comment, - sym_include, - [88866] = 9, - ACTIONS(373), 1, + [107033] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2616), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1909), 2, + ACTIONS(1704), 1, + aux_sym_variable_definition_token2, + STATE(2380), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [88896] = 9, - ACTIONS(373), 1, + ACTIONS(1912), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107055] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2337), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1910), 2, + ACTIONS(3527), 1, + sym_identifier, + STATE(280), 1, + sym_qualified_name, + ACTIONS(3529), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2381), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [88926] = 9, - ACTIONS(373), 1, + [107079] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2337), 1, - sym__terminator, - STATE(1872), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1911), 2, + ACTIONS(3517), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2382), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [88956] = 10, - ACTIONS(373), 1, + ACTIONS(3531), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [107101] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3533), 1, + sym_identifier, + STATE(2383), 2, + sym_comment, + sym_include, + ACTIONS(3535), 3, anon_sym_COMMA, - ACTIONS(2004), 1, anon_sym_COLON, - ACTIONS(2720), 1, aux_sym_on_error_phrase_token1, - STATE(2060), 1, + [107123] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3537), 1, + anon_sym_COLON, + STATE(2704), 1, sym_on_quit_phrase, - STATE(2321), 1, - aux_sym_for_statement_repeat1, - STATE(2337), 1, + STATE(3421), 1, sym_on_stop_phrase, - STATE(1912), 2, + STATE(2384), 2, sym_comment, sym_include, - [88988] = 10, - ACTIONS(373), 1, + [107149] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2379), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1951), 1, - sym_on_quit_phrase, - STATE(2441), 1, - sym_on_stop_phrase, - STATE(2443), 1, - aux_sym_for_statement_repeat1, - STATE(1913), 2, + ACTIONS(3541), 1, + aux_sym_variable_definition_token2, + STATE(2385), 2, sym_comment, sym_include, - [89020] = 9, - ACTIONS(373), 1, + ACTIONS(3539), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107171] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2796), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1914), 2, + ACTIONS(3543), 1, + sym_identifier, + STATE(2386), 2, sym_comment, sym_include, - [89050] = 9, - ACTIONS(373), 1, + ACTIONS(3545), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [107193] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2798), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1915), 2, + ACTIONS(3549), 1, + aux_sym_variable_definition_token2, + STATE(2387), 2, sym_comment, sym_include, - [89080] = 9, - ACTIONS(373), 1, + ACTIONS(3547), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107215] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2800), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1916), 2, + ACTIONS(3551), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2388), 2, sym_comment, sym_include, - [89110] = 10, - ACTIONS(373), 1, + ACTIONS(3553), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [107237] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2046), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1981), 1, + ACTIONS(3555), 1, + anon_sym_COLON, + STATE(2697), 1, sym_on_quit_phrase, - STATE(2195), 1, - aux_sym_for_statement_repeat1, - STATE(2202), 1, + STATE(3424), 1, sym_on_stop_phrase, - STATE(1917), 2, + STATE(2389), 2, sym_comment, sym_include, - [89142] = 10, - ACTIONS(373), 1, + [107263] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1952), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1956), 1, - sym_on_quit_phrase, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, - aux_sym_for_statement_repeat1, - STATE(1918), 2, + ACTIONS(3559), 1, + aux_sym_variable_definition_token2, + STATE(2390), 2, sym_comment, sym_include, - [89174] = 10, - ACTIONS(373), 1, + ACTIONS(3557), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107285] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2802), 1, - anon_sym_COLON, - STATE(1977), 1, - sym_on_quit_phrase, - STATE(2465), 1, - aux_sym_for_statement_repeat1, - STATE(2467), 1, - sym_on_stop_phrase, - STATE(1919), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(3781), 1, + sym_data_relation, + STATE(2391), 2, sym_comment, sym_include, - [89206] = 9, - ACTIONS(373), 1, + [107311] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2804), 1, - sym__terminator, - STATE(1838), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1920), 2, + ACTIONS(3503), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2392), 2, sym_comment, sym_include, - [89236] = 10, - ACTIONS(373), 1, + ACTIONS(3561), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [107333] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3098), 1, + sym_on_stop_phrase, + ACTIONS(2116), 2, anon_sym_COMMA, - ACTIONS(1984), 1, anon_sym_COLON, - ACTIONS(2720), 1, + STATE(2393), 2, + sym_comment, + sym_include, + [107357] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1957), 1, + ACTIONS(3563), 1, + anon_sym_COLON, + STATE(2681), 1, sym_on_quit_phrase, - STATE(2333), 1, + STATE(3452), 1, sym_on_stop_phrase, - STATE(2418), 1, - aux_sym_for_statement_repeat1, - STATE(1921), 2, + STATE(2394), 2, sym_comment, sym_include, - [89268] = 5, - ACTIONS(3), 1, + [107383] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1922), 2, + STATE(2395), 2, sym_comment, sym_include, - ACTIONS(2806), 6, - sym_identifier, + ACTIONS(3565), 4, + sym__terminator, anon_sym_COMMA, anon_sym_COLON, aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [89290] = 5, - ACTIONS(3), 1, + [107403] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1923), 2, + STATE(2396), 2, sym_comment, sym_include, - ACTIONS(2808), 6, - sym_identifier, + ACTIONS(3567), 4, sym__terminator, - aux_sym_variable_definition_token5, - aux_sym_field_definition_token1, - aux_sym_index_tuning_token1, - aux_sym_index_definition_token1, - [89312] = 10, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, anon_sym_COMMA, - ACTIONS(1960), 1, anon_sym_COLON, - ACTIONS(2720), 1, aux_sym_on_error_phrase_token1, - STATE(1947), 1, - sym_on_quit_phrase, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, - sym_on_stop_phrase, - STATE(1924), 2, + [107423] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3571), 1, + aux_sym_variable_definition_token2, + STATE(2397), 2, sym_comment, sym_include, - [89344] = 5, - ACTIONS(3), 1, + ACTIONS(3569), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107445] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1925), 2, + ACTIONS(3575), 1, + aux_sym_variable_definition_token2, + STATE(2398), 2, sym_comment, sym_include, - ACTIONS(2810), 6, - sym_identifier, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [89366] = 10, - ACTIONS(373), 1, + ACTIONS(3573), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107467] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2006), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1988), 1, - sym_on_quit_phrase, - STATE(2200), 1, - sym_on_stop_phrase, - STATE(2224), 1, - aux_sym_for_statement_repeat1, - STATE(1926), 2, + ACTIONS(3579), 1, + aux_sym_variable_definition_token2, + STATE(2399), 2, sym_comment, sym_include, - [89398] = 10, - ACTIONS(373), 1, + ACTIONS(3577), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107489] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2016), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2011), 1, - sym_on_quit_phrase, - STATE(2374), 1, - aux_sym_for_statement_repeat1, - STATE(2393), 1, - sym_on_stop_phrase, - STATE(1927), 2, + ACTIONS(1842), 1, + aux_sym_variable_definition_token2, + STATE(2400), 2, sym_comment, sym_include, - [89430] = 9, - ACTIONS(373), 1, + ACTIONS(1992), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107511] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2812), 1, + STATE(2401), 2, + sym_comment, + sym_include, + ACTIONS(3581), 4, sym__terminator, - STATE(1935), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, + aux_sym_query_definition_tuning_token1, anon_sym_SCROLLING, aux_sym_query_definition_tuning_token2, - STATE(1928), 2, + [107531] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3583), 1, + anon_sym_COLON, + STATE(2842), 1, + sym_on_quit_phrase, + STATE(3583), 1, + sym_on_stop_phrase, + STATE(2402), 2, sym_comment, sym_include, - [89460] = 8, - ACTIONS(373), 1, + [107557] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2814), 1, - sym__terminator, - ACTIONS(2816), 1, - aux_sym_field_definition_token1, - ACTIONS(2819), 1, - aux_sym_index_definition_token1, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - STATE(1929), 3, + STATE(2403), 2, sym_comment, sym_include, - aux_sym_temp_table_definition_repeat2, - [89488] = 9, - ACTIONS(3), 1, + ACTIONS(3249), 4, + anon_sym_RPAREN, + anon_sym_COMMA, + aux_sym_data_relation_token1, + aux_sym_data_relation_token2, + [107577] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2766), 1, - sym_identifier, - ACTIONS(2770), 1, - aux_sym_field_definition_token1, - STATE(1865), 1, - aux_sym_widget_phrase_repeat1, - STATE(2136), 1, - sym_widget_field, - ACTIONS(2822), 2, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - STATE(1930), 2, + STATE(2404), 2, sym_comment, sym_include, - [89518] = 10, - ACTIONS(373), 1, + ACTIONS(3585), 4, + sym__terminator, + aux_sym_query_definition_tuning_token1, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + [107597] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1940), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1990), 1, + ACTIONS(3587), 1, + anon_sym_COLON, + STATE(2712), 1, sym_on_quit_phrase, - STATE(2209), 1, + STATE(3414), 1, sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1931), 2, + STATE(2405), 2, sym_comment, sym_include, - [89550] = 9, - ACTIONS(373), 1, + [107623] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2317), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1932), 2, + STATE(2406), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [89580] = 10, - ACTIONS(373), 1, + ACTIONS(3589), 4, + sym__terminator, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [107643] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3591), 1, + sym_identifier, + STATE(2407), 2, + sym_comment, + sym_include, + ACTIONS(3593), 3, anon_sym_COMMA, - ACTIONS(2406), 1, anon_sym_COLON, - ACTIONS(2720), 1, aux_sym_on_error_phrase_token1, - STATE(2035), 1, + [107665] = 8, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3177), 1, + anon_sym_COLON, + ACTIONS(3193), 1, + aux_sym_on_error_phrase_token1, + STATE(2770), 1, sym_on_quit_phrase, - STATE(2400), 1, - aux_sym_for_statement_repeat1, - STATE(2437), 1, + STATE(3460), 1, sym_on_stop_phrase, - STATE(1933), 2, + STATE(2408), 2, sym_comment, sym_include, - [89612] = 10, - ACTIONS(373), 1, + [107691] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2824), 1, + ACTIONS(3595), 1, anon_sym_COLON, - STATE(1954), 1, + STATE(2854), 1, sym_on_quit_phrase, - STATE(2246), 1, + STATE(3639), 1, sym_on_stop_phrase, - STATE(2256), 1, - aux_sym_for_statement_repeat1, - STATE(1934), 2, + STATE(2409), 2, sym_comment, sym_include, - [89644] = 9, - ACTIONS(373), 1, + [107717] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2576), 1, - aux_sym_query_definition_tuning_token1, - ACTIONS(2826), 1, - sym__terminator, - STATE(1893), 1, - aux_sym_query_definition_repeat1, - STATE(2082), 1, - sym_query_definition_tuning, - ACTIONS(2578), 2, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - STATE(1935), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3351), 1, + sym_on_stop_phrase, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2410), 2, sym_comment, sym_include, - [89674] = 10, - ACTIONS(373), 1, + [107741] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1972), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2030), 1, - sym_on_quit_phrase, - STATE(2434), 1, - aux_sym_for_statement_repeat1, - STATE(2435), 1, - sym_on_stop_phrase, - STATE(1936), 2, + ACTIONS(1794), 1, + aux_sym_variable_definition_token2, + STATE(2411), 2, sym_comment, sym_include, - [89706] = 9, - ACTIONS(373), 1, + ACTIONS(1792), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107763] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2290), 1, - sym__terminator, - STATE(1929), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1937), 2, + ACTIONS(3597), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2412), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [89736] = 10, - ACTIONS(373), 1, + ACTIONS(3599), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [107785] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2828), 1, - anon_sym_COLON, - STATE(1975), 1, - sym_on_quit_phrase, - STATE(2191), 1, - aux_sym_for_statement_repeat1, - STATE(2201), 1, + STATE(3265), 1, sym_on_stop_phrase, - STATE(1938), 2, + ACTIONS(3392), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2413), 2, sym_comment, sym_include, - [89768] = 10, - ACTIONS(373), 1, + [107809] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1980), 1, + ACTIONS(3119), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1971), 1, + STATE(2633), 1, sym_on_quit_phrase, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, + STATE(3544), 1, sym_on_stop_phrase, - STATE(1939), 2, + STATE(2414), 2, sym_comment, sym_include, - [89800] = 10, - ACTIONS(373), 1, + [107835] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2830), 1, + ACTIONS(3601), 1, anon_sym_COLON, - STATE(1980), 1, + STATE(2858), 1, sym_on_quit_phrase, - STATE(2406), 1, + STATE(3645), 1, sym_on_stop_phrase, - STATE(2408), 1, - aux_sym_for_statement_repeat1, - STATE(1940), 2, + STATE(2415), 2, sym_comment, sym_include, - [89832] = 10, - ACTIONS(373), 1, + [107861] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1978), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1998), 1, - sym_on_quit_phrase, - STATE(2391), 1, - sym_on_stop_phrase, - STATE(2392), 1, - aux_sym_for_statement_repeat1, - STATE(1941), 2, + ACTIONS(3603), 1, + sym_identifier, + STATE(279), 1, + sym_qualified_name, + ACTIONS(3605), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2416), 2, sym_comment, sym_include, - [89864] = 10, - ACTIONS(373), 1, + [107885] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1986), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1995), 1, - sym_on_quit_phrase, - STATE(2221), 1, - aux_sym_for_statement_repeat1, - STATE(2294), 1, - sym_on_stop_phrase, - STATE(1942), 2, + ACTIONS(1692), 1, + aux_sym_variable_definition_token2, + STATE(2417), 2, sym_comment, sym_include, - [89896] = 10, - ACTIONS(373), 1, + ACTIONS(1690), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [107907] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1946), 1, - anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(1948), 1, - sym_on_quit_phrase, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 1, - sym_on_stop_phrase, - STATE(1943), 2, + ACTIONS(3607), 1, + sym_identifier, + STATE(291), 1, + sym_qualified_name, + ACTIONS(3609), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2418), 2, sym_comment, sym_include, - [89928] = 9, - ACTIONS(373), 1, + [107931] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2282), 1, - aux_sym_field_definition_token1, - ACTIONS(2284), 1, - aux_sym_index_definition_token1, - ACTIONS(2317), 1, - sym__terminator, - STATE(1859), 1, - aux_sym_temp_table_definition_repeat2, - STATE(1944), 2, + ACTIONS(460), 1, + sym_identifier, + STATE(2419), 2, sym_comment, sym_include, - STATE(2496), 2, - sym_field_definition, - sym_index_definition, - [89958] = 10, - ACTIONS(373), 1, + ACTIONS(458), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [107951] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2010), 1, + ACTIONS(3129), 1, anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(1986), 1, + STATE(2877), 1, sym_on_quit_phrase, - STATE(2480), 1, + STATE(3680), 1, sym_on_stop_phrase, - STATE(2481), 1, - aux_sym_for_statement_repeat1, - STATE(1945), 2, + STATE(2420), 2, sym_comment, sym_include, - [89990] = 8, - ACTIONS(373), 1, + [107977] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(2118), 1, + ACTIONS(3611), 1, + anon_sym_COLON, + STATE(2622), 1, sym_on_quit_phrase, - STATE(2954), 1, + STATE(3563), 1, sym_on_stop_phrase, - ACTIONS(2443), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1946), 2, + STATE(2421), 2, sym_comment, sym_include, - [90017] = 9, - ACTIONS(373), 1, + [108003] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1976), 1, + STATE(2422), 2, + sym_comment, + sym_include, + ACTIONS(3613), 4, anon_sym_COLON, - ACTIONS(2832), 1, aux_sym_on_error_phrase_token1, - STATE(2336), 1, - sym_on_stop_phrase, - STATE(2342), 1, - aux_sym_for_statement_repeat1, - STATE(1947), 2, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + [108023] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + STATE(2423), 2, sym_comment, sym_include, - [90046] = 9, - ACTIONS(373), 1, + ACTIONS(3615), 4, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + aux_sym_field_definition_token1, + [108043] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1988), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2210), 1, - sym_on_stop_phrase, - STATE(2231), 1, - aux_sym_for_statement_repeat1, - STATE(1948), 2, + ACTIONS(3617), 1, + aux_sym_stream_definition_token1, + ACTIONS(3619), 1, + aux_sym_input_close_statement_token1, + ACTIONS(3621), 1, + aux_sym_input_close_statement_token2, + ACTIONS(3623), 1, + aux_sym_output_stream_statement_token1, + STATE(2424), 2, sym_comment, sym_include, - [90075] = 7, - ACTIONS(373), 1, + [108069] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2836), 1, - aux_sym_case_when_branch_token1, - STATE(2279), 1, - sym_case_when_branch, - ACTIONS(2834), 2, - aux_sym__block_terminator_token1, - aux_sym_case_otherwise_branch_token1, - STATE(1949), 3, + ACTIONS(3625), 1, + aux_sym_stream_definition_token1, + ACTIONS(3627), 1, + aux_sym_input_close_statement_token1, + ACTIONS(3629), 1, + aux_sym_input_close_statement_token2, + ACTIONS(3631), 1, + aux_sym_input_stream_statement_token1, + STATE(2425), 2, sym_comment, sym_include, - aux_sym_case_body_repeat1, - [90100] = 7, - ACTIONS(373), 1, + [108095] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2839), 1, - anon_sym_COLON, - ACTIONS(2841), 1, - aux_sym_on_error_phrase_token1, - STATE(1950), 2, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2432), 1, + aux_sym_data_relation_repeat1, + STATE(3781), 1, + sym_data_relation, + STATE(2426), 2, sym_comment, sym_include, - STATE(3276), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [90125] = 9, - ACTIONS(373), 1, + [108121] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2830), 1, + STATE(2427), 2, + sym_comment, + sym_include, + ACTIONS(3633), 4, anon_sym_COLON, - ACTIONS(2832), 1, aux_sym_on_error_phrase_token1, - STATE(2406), 1, - sym_on_stop_phrase, - STATE(2408), 1, - aux_sym_for_statement_repeat1, - STATE(1951), 2, + aux_sym_stop_after_phrase_token1, + aux_sym_do_tuning_token1, + [108141] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3637), 1, + aux_sym_variable_definition_token2, + STATE(2428), 2, sym_comment, sym_include, - [90154] = 9, - ACTIONS(373), 1, + ACTIONS(3635), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108163] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1169), 1, - sym_do_block, - STATE(2043), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1952), 2, + ACTIONS(3641), 1, + aux_sym_variable_definition_token2, + STATE(2429), 2, sym_comment, sym_include, - [90183] = 9, - ACTIONS(373), 1, + ACTIONS(3639), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108185] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1169), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1953), 2, + ACTIONS(3643), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2430), 2, sym_comment, sym_include, - [90212] = 9, - ACTIONS(373), 1, + [108209] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2843), 1, - anon_sym_COLON, - STATE(2239), 1, - sym_on_stop_phrase, - STATE(2241), 1, - aux_sym_for_statement_repeat1, - STATE(1954), 2, + ACTIONS(3647), 1, + anon_sym_DQUOTE, + STATE(2430), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2431), 2, sym_comment, sym_include, - [90241] = 9, - ACTIONS(373), 1, + [108233] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2828), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2191), 1, - aux_sym_for_statement_repeat1, - STATE(2201), 1, - sym_on_stop_phrase, - STATE(1955), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(3574), 1, + sym_data_relation, + STATE(2432), 2, sym_comment, sym_include, - [90270] = 9, - ACTIONS(373), 1, + [108259] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1972), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2434), 1, - aux_sym_for_statement_repeat1, - STATE(2435), 1, - sym_on_stop_phrase, - STATE(1956), 2, + ACTIONS(1596), 1, + aux_sym_variable_definition_token2, + STATE(2433), 2, sym_comment, sym_include, - [90299] = 9, - ACTIONS(373), 1, + ACTIONS(1594), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108281] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2038), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2542), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 1, - sym_on_stop_phrase, - STATE(1957), 2, + ACTIONS(3651), 1, + aux_sym_variable_definition_token2, + STATE(2434), 2, sym_comment, sym_include, - [90328] = 9, - ACTIONS(373), 1, + ACTIONS(3649), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108303] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1980), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2186), 1, - aux_sym_for_statement_repeat1, - STATE(2189), 1, + STATE(3086), 1, sym_on_stop_phrase, - STATE(1958), 2, + ACTIONS(2186), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2435), 2, sym_comment, sym_include, - [90357] = 7, - ACTIONS(373), 1, + [108327] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2841), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2845), 1, + ACTIONS(3653), 1, anon_sym_COLON, - STATE(1959), 2, + STATE(2612), 1, + sym_on_quit_phrase, + STATE(3595), 1, + sym_on_stop_phrase, + STATE(2436), 2, sym_comment, sym_include, - STATE(3125), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [90382] = 9, - ACTIONS(373), 1, + [108353] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1978), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2391), 1, - sym_on_stop_phrase, - STATE(2392), 1, - aux_sym_for_statement_repeat1, - STATE(1960), 2, + ACTIONS(3657), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2437), 2, sym_comment, sym_include, - [90411] = 7, - ACTIONS(373), 1, + [108377] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2847), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2851), 1, - aux_sym_on_error_phrase_token8, - STATE(1961), 2, + ACTIONS(3659), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2438), 2, sym_comment, sym_include, - ACTIONS(2849), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [90436] = 5, - ACTIONS(373), 1, + [108401] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(1962), 2, + ACTIONS(3663), 1, + aux_sym_variable_definition_token2, + STATE(2439), 2, sym_comment, sym_include, - ACTIONS(2853), 5, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - aux_sym_sort_clause_token1, - aux_sym_sort_clause_token2, - [90457] = 9, - ACTIONS(373), 1, + ACTIONS(3661), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108423] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2855), 1, - anon_sym_COLON, - STATE(2162), 1, - sym_on_error_phrase, - STATE(2233), 1, - sym_on_quit_phrase, - STATE(3007), 1, - sym_on_stop_phrase, - STATE(1963), 2, + ACTIONS(3665), 1, + anon_sym_SQUOTE, + STATE(2437), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2440), 2, sym_comment, sym_include, - [90486] = 9, - ACTIONS(373), 1, + [108447] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2857), 1, - anon_sym_COLON, - STATE(2423), 1, - sym_on_stop_phrase, - STATE(2425), 1, - aux_sym_for_statement_repeat1, - STATE(1964), 2, + ACTIONS(3667), 1, + anon_sym_DQUOTE, + STATE(2438), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2441), 2, sym_comment, sym_include, - [90515] = 9, - ACTIONS(373), 1, + [108471] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2859), 1, - anon_sym_COLON, - STATE(2183), 1, - sym_on_stop_phrase, - STATE(2226), 1, - aux_sym_for_statement_repeat1, - STATE(1965), 2, + ACTIONS(420), 1, + sym_identifier, + STATE(2442), 2, sym_comment, sym_include, - [90544] = 9, - ACTIONS(373), 1, + ACTIONS(418), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108491] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1940), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2209), 1, - sym_on_stop_phrase, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(1966), 2, + STATE(2443), 2, + sym_comment, + sym_include, + ACTIONS(3669), 4, + sym__terminator, + aux_sym_query_definition_tuning_token1, + anon_sym_SCROLLING, + aux_sym_query_definition_tuning_token2, + [108511] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(3671), 1, + sym_identifier, + STATE(2444), 2, sym_comment, sym_include, - [90573] = 9, - ACTIONS(373), 1, + ACTIONS(3673), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108531] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(3675), 1, + sym_identifier, + STATE(2445), 2, + sym_comment, + sym_include, + ACTIONS(3677), 4, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2406), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2400), 1, - aux_sym_for_statement_repeat1, - STATE(2437), 1, - sym_on_stop_phrase, - STATE(1967), 2, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108551] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(3679), 1, + sym_identifier, + STATE(2446), 2, sym_comment, sym_include, - [90602] = 9, - ACTIONS(373), 1, + ACTIONS(3681), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108571] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(3683), 1, + sym_identifier, + STATE(2447), 2, + sym_comment, + sym_include, + ACTIONS(3685), 4, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2824), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2246), 1, - sym_on_stop_phrase, - STATE(2256), 1, - aux_sym_for_statement_repeat1, - STATE(1968), 2, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108591] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(500), 1, + sym_identifier, + STATE(2448), 2, sym_comment, sym_include, - [90631] = 7, - ACTIONS(373), 1, + ACTIONS(498), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108611] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2841), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2861), 1, - anon_sym_COLON, - STATE(1969), 2, + ACTIONS(3687), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2449), 2, sym_comment, sym_include, - STATE(3037), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [90656] = 8, + [108635] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2863), 1, - sym_identifier, - STATE(1711), 1, - aux_sym_sort_clause_repeat1, - STATE(1894), 1, - sym_sort_column, - STATE(1638), 2, - sym_qualified_name, - sym_function_call, - STATE(1970), 2, + ACTIONS(3689), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2450), 2, sym_comment, sym_include, - [90683] = 9, - ACTIONS(373), 1, + [108659] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2016), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2374), 1, - aux_sym_for_statement_repeat1, - STATE(2393), 1, + STATE(3022), 1, sym_on_stop_phrase, - STATE(1971), 2, + ACTIONS(2869), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2451), 2, sym_comment, sym_include, - [90712] = 9, - ACTIONS(373), 1, + [108683] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2353), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3691), 1, + sym_identifier, + STATE(288), 1, + sym_qualified_name, + ACTIONS(3693), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2452), 2, + sym_comment, + sym_include, + [108707] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2474), 1, - aux_sym_for_statement_repeat1, - STATE(2482), 1, + STATE(3137), 1, sym_on_stop_phrase, - STATE(1972), 2, + ACTIONS(2182), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2453), 2, sym_comment, sym_include, - [90741] = 9, - ACTIONS(373), 1, + [108731] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1964), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 1, - sym_on_stop_phrase, - STATE(1973), 2, + STATE(2454), 2, sym_comment, sym_include, - [90770] = 7, + ACTIONS(3695), 4, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + aux_sym_field_definition_token1, + [108751] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2865), 1, - sym_identifier, - STATE(2283), 1, - sym_assignment, - ACTIONS(2868), 2, - sym__terminator, - anon_sym_NO_DASHERROR, - STATE(1974), 3, + ACTIONS(3697), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2455), 2, sym_comment, sym_include, - aux_sym_assign_statement_repeat1, - [90795] = 9, - ACTIONS(373), 1, + [108775] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2870), 1, - anon_sym_COLON, - STATE(2229), 1, - aux_sym_for_statement_repeat1, - STATE(2264), 1, - sym_on_stop_phrase, - STATE(1975), 2, + ACTIONS(3699), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2456), 2, sym_comment, sym_include, - [90824] = 8, - ACTIONS(373), 1, + [108799] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2111), 1, - sym_on_quit_phrase, - STATE(2957), 1, - sym_on_stop_phrase, - ACTIONS(2068), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1976), 2, + ACTIONS(3701), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2457), 2, sym_comment, sym_include, - [90851] = 9, - ACTIONS(373), 1, + [108823] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2872), 1, - anon_sym_COLON, - STATE(2508), 1, - aux_sym_for_statement_repeat1, - STATE(2509), 1, - sym_on_stop_phrase, - STATE(1977), 2, + ACTIONS(3703), 1, + anon_sym_SQUOTE, + STATE(2456), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2458), 2, sym_comment, sym_include, - [90880] = 9, - ACTIONS(373), 1, + [108847] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1952), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2249), 1, - sym_on_stop_phrase, - STATE(2268), 1, - aux_sym_for_statement_repeat1, - STATE(1978), 2, + ACTIONS(3705), 1, + anon_sym_DQUOTE, + STATE(2457), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2459), 2, sym_comment, sym_include, - [90909] = 9, - ACTIONS(373), 1, + [108871] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1960), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2379), 1, - sym_on_stop_phrase, - STATE(1979), 2, + ACTIONS(3707), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2460), 2, sym_comment, sym_include, - [90938] = 9, - ACTIONS(373), 1, + [108895] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - ACTIONS(2874), 1, + ACTIONS(3709), 1, anon_sym_COLON, - STATE(2385), 1, + STATE(2535), 1, + sym_on_quit_phrase, + STATE(3681), 1, sym_on_stop_phrase, - STATE(2386), 1, - aux_sym_for_statement_repeat1, - STATE(1980), 2, + STATE(2461), 2, sym_comment, sym_include, - [90967] = 9, - ACTIONS(373), 1, + [108921] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2004), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2321), 1, - aux_sym_for_statement_repeat1, - STATE(2337), 1, - sym_on_stop_phrase, - STATE(1981), 2, + STATE(2462), 2, sym_comment, sym_include, - [90996] = 9, - ACTIONS(373), 1, + ACTIONS(3711), 4, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + aux_sym_field_definition_token1, + [108941] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2876), 1, - anon_sym_COLON, - STATE(2266), 1, - sym_on_stop_phrase, - STATE(2280), 1, - aux_sym_for_statement_repeat1, - STATE(1982), 2, + ACTIONS(408), 1, + sym_identifier, + STATE(2463), 2, sym_comment, sym_include, - [91025] = 9, - ACTIONS(373), 1, + ACTIONS(406), 4, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_DQUOTE, + aux_sym_include_argument_token1, + [108961] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2046), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2195), 1, - aux_sym_for_statement_repeat1, - STATE(2202), 1, - sym_on_stop_phrase, - STATE(1983), 2, + ACTIONS(3715), 1, + aux_sym_variable_definition_token2, + STATE(2464), 2, sym_comment, sym_include, - [91054] = 8, - ACTIONS(373), 1, + ACTIONS(3713), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [108983] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2878), 1, - anon_sym_DQUOTE, - ACTIONS(2880), 1, - anon_sym_SQUOTE, - STATE(1731), 1, - sym__string_literal, - STATE(636), 2, - sym_double_quoted_string, - sym_single_quoted_string, - STATE(1984), 2, + ACTIONS(3717), 1, + sym_identifier, + STATE(283), 1, + sym_qualified_name, + ACTIONS(3719), 2, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + STATE(2465), 2, sym_comment, sym_include, - [91081] = 9, - ACTIONS(373), 1, + [109007] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2882), 1, - anon_sym_COLON, - STATE(2157), 1, - sym_on_error_phrase, - STATE(2242), 1, - sym_on_quit_phrase, - STATE(3097), 1, - sym_on_stop_phrase, - STATE(1985), 2, + ACTIONS(3723), 1, + aux_sym_variable_definition_token2, + STATE(2466), 2, sym_comment, sym_include, - [91110] = 9, - ACTIONS(373), 1, + ACTIONS(3721), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [109029] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1090), 1, anon_sym_COMMA, - ACTIONS(2379), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2441), 1, - sym_on_stop_phrase, - STATE(2443), 1, - aux_sym_for_statement_repeat1, - STATE(1986), 2, + ACTIONS(3725), 1, + aux_sym_of_token1, + ACTIONS(3727), 1, + aux_sym_on_statement_token1, + STATE(2477), 1, + aux_sym_on_statement_repeat1, + STATE(2467), 2, sym_comment, sym_include, - [91139] = 9, - ACTIONS(373), 1, + [109055] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2802), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2465), 1, - aux_sym_for_statement_repeat1, - STATE(2467), 1, - sym_on_stop_phrase, - STATE(1987), 2, + STATE(2468), 2, sym_comment, sym_include, - [91168] = 9, - ACTIONS(373), 1, + ACTIONS(3256), 4, + sym_identifier, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [109075] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2042), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2531), 1, - aux_sym_for_statement_repeat1, - STATE(2541), 1, - sym_on_stop_phrase, - STATE(1988), 2, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(3435), 1, + sym_data_relation, + STATE(2469), 2, sym_comment, sym_include, - [91197] = 9, - ACTIONS(373), 1, + [109101] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1275), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(1989), 2, + ACTIONS(3729), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2470), 2, sym_comment, sym_include, - [91226] = 9, - ACTIONS(373), 1, + [109125] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1984), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2333), 1, - sym_on_stop_phrase, - STATE(2418), 1, - aux_sym_for_statement_repeat1, - STATE(1990), 2, + ACTIONS(3731), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2471), 2, sym_comment, sym_include, - [91255] = 7, - ACTIONS(373), 1, + [109149] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2841), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2884), 1, - anon_sym_COLON, - STATE(1991), 2, + ACTIONS(3733), 1, + anon_sym_SQUOTE, + STATE(2470), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2472), 2, sym_comment, sym_include, - STATE(3248), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [91280] = 7, - ACTIONS(373), 1, + [109173] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2886), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2890), 1, - aux_sym_on_error_phrase_token8, - STATE(1992), 2, + ACTIONS(3735), 1, + anon_sym_DQUOTE, + STATE(2471), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2473), 2, sym_comment, sym_include, - ACTIONS(2888), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [91305] = 6, + [109197] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2894), 1, - aux_sym_widget_field_token1, - STATE(1993), 2, + ACTIONS(3737), 1, + anon_sym_SQUOTE, + STATE(2455), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2474), 2, sym_comment, sym_include, - ACTIONS(2892), 4, - sym_identifier, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - aux_sym_field_definition_token1, - [91328] = 8, - ACTIONS(373), 1, + [109221] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2119), 1, - sym_on_quit_phrase, - STATE(2950), 1, - sym_on_stop_phrase, - ACTIONS(2896), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(1994), 2, + ACTIONS(3739), 1, + anon_sym_DQUOTE, + STATE(2460), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2475), 2, sym_comment, sym_include, - [91355] = 9, - ACTIONS(373), 1, + [109245] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2002), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3193), 1, aux_sym_on_error_phrase_token1, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2356), 1, + ACTIONS(3741), 1, + anon_sym_COLON, + STATE(2670), 1, + sym_on_quit_phrase, + STATE(3700), 1, sym_on_stop_phrase, - STATE(1995), 2, + STATE(2476), 2, sym_comment, sym_include, - [91384] = 9, - ACTIONS(373), 1, + [109271] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3743), 1, anon_sym_COMMA, - ACTIONS(1948), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2468), 1, - sym_on_stop_phrase, - STATE(2523), 1, - aux_sym_for_statement_repeat1, - STATE(1996), 2, + ACTIONS(1117), 2, + aux_sym_of_token1, + aux_sym_on_statement_token1, + STATE(2477), 3, sym_comment, sym_include, - [91413] = 7, - ACTIONS(373), 1, + aux_sym_on_statement_repeat1, + [109293] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2841), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2898), 1, - anon_sym_COLON, - STATE(1997), 2, + ACTIONS(3746), 1, + anon_sym_DQUOTE, + ACTIONS(3748), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2478), 3, sym_comment, sym_include, - STATE(3012), 3, - sym_on_error_phrase, - sym_on_stop_phrase, - sym_on_quit_phrase, - [91438] = 9, - ACTIONS(373), 1, + aux_sym_double_quoted_string_repeat1, + [109315] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2012), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2362), 1, - sym_on_stop_phrase, - STATE(2363), 1, - aux_sym_for_statement_repeat1, - STATE(1998), 2, + ACTIONS(3754), 1, + anon_sym_SQUOTE, + ACTIONS(3751), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2479), 3, sym_comment, sym_include, - [91467] = 9, - ACTIONS(373), 1, + aux_sym_single_quoted_string_repeat1, + [109337] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2900), 1, - anon_sym_COLON, - STATE(2179), 1, - sym_on_error_phrase, - STATE(2204), 1, - sym_on_quit_phrase, - STATE(3115), 1, - sym_on_stop_phrase, - STATE(1999), 2, + STATE(3028), 1, + sym_for_phrase, + STATE(2480), 2, sym_comment, sym_include, - [91496] = 9, - ACTIONS(373), 1, + ACTIONS(3756), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109359] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1090), 1, anon_sym_COMMA, - ACTIONS(2365), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2286), 1, - sym_on_stop_phrase, - STATE(2293), 1, - aux_sym_for_statement_repeat1, - STATE(2000), 2, + ACTIONS(3758), 1, + aux_sym_of_token1, + ACTIONS(3760), 1, + aux_sym_on_statement_token1, + STATE(2477), 1, + aux_sym_on_statement_repeat1, + STATE(2481), 2, sym_comment, sym_include, - [91525] = 9, - ACTIONS(373), 1, + [109385] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2006), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2200), 1, - sym_on_stop_phrase, - STATE(2224), 1, - aux_sym_for_statement_repeat1, - STATE(2001), 2, + STATE(2482), 2, sym_comment, sym_include, - [91554] = 5, - ACTIONS(373), 1, + ACTIONS(3262), 4, + sym_identifier, + sym__terminator, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [109405] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2002), 2, + STATE(2483), 2, sym_comment, sym_include, - ACTIONS(2902), 5, + ACTIONS(3260), 4, + sym_identifier, sym__terminator, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - aux_sym_query_definition_token3, - [91575] = 8, + aux_sym_field_definition_token1, + aux_sym_index_definition_token1, + [109425] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2732), 1, - sym_identifier, - STATE(2940), 1, - sym_function_parameter, - STATE(3034), 1, - sym_function_parameter_mode, - ACTIONS(2736), 2, - aux_sym_input_expression_token1, - aux_sym_argument_mode_token1, - STATE(2003), 2, + ACTIONS(3762), 1, + anon_sym_SQUOTE, + STATE(2450), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2484), 2, sym_comment, sym_include, - [91602] = 9, - ACTIONS(373), 1, + [109449] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1358), 1, - sym_do_block, - STATE(1989), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2004), 2, + ACTIONS(3766), 1, + aux_sym_variable_definition_token2, + STATE(2485), 2, sym_comment, sym_include, - [91631] = 9, - ACTIONS(373), 1, + ACTIONS(3764), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [109471] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2904), 1, - anon_sym_COLON, - STATE(2165), 1, - sym_on_error_phrase, - STATE(2214), 1, - sym_on_quit_phrase, - STATE(3120), 1, - sym_on_stop_phrase, - STATE(2005), 2, + ACTIONS(3768), 1, + anon_sym_DQUOTE, + STATE(2478), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2486), 2, sym_comment, sym_include, - [91660] = 9, - ACTIONS(373), 1, + [109495] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2790), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2297), 1, - sym_on_stop_phrase, - STATE(2299), 1, - aux_sym_for_statement_repeat1, - STATE(2006), 2, + ACTIONS(3597), 1, + aux_sym_procedure_parameter_definition_token1, + STATE(2487), 2, sym_comment, sym_include, - [91689] = 9, - ACTIONS(373), 1, + ACTIONS(3770), 3, + aux_sym_on_error_phrase_token4, + aux_sym_on_error_phrase_token5, + aux_sym_on_error_phrase_token6, + [109517] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1358), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2007), 2, + ACTIONS(3772), 1, + anon_sym_DQUOTE, + STATE(2449), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2488), 2, sym_comment, sym_include, - [91718] = 9, - ACTIONS(373), 1, + [109541] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1308), 1, - sym_do_block, - STATE(2052), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2008), 2, + ACTIONS(3774), 1, + anon_sym_SQUOTE, + STATE(2479), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2489), 2, sym_comment, sym_include, - [91747] = 9, - ACTIONS(373), 1, + [109565] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2906), 1, - anon_sym_COLON, - STATE(2138), 1, - sym_on_error_phrase, - STATE(2303), 1, - sym_on_quit_phrase, - STATE(2982), 1, - sym_on_stop_phrase, - STATE(2009), 2, + ACTIONS(3776), 1, + anon_sym_DQUOTE, + STATE(2486), 1, + aux_sym_double_quoted_string_repeat1, + ACTIONS(3645), 2, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + STATE(2490), 2, sym_comment, sym_include, - [91776] = 9, - ACTIONS(373), 1, + [109589] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1308), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2010), 2, + ACTIONS(3778), 1, + anon_sym_SQUOTE, + STATE(2489), 1, + aux_sym_single_quoted_string_repeat1, + ACTIONS(3655), 2, + aux_sym_double_quoted_string_token2, + aux_sym_single_quoted_string_token1, + STATE(2491), 2, sym_comment, sym_include, - [91805] = 9, - ACTIONS(373), 1, + [109613] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2010), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2480), 1, - sym_on_stop_phrase, - STATE(2481), 1, - aux_sym_for_statement_repeat1, - STATE(2011), 2, + ACTIONS(3782), 1, + aux_sym_variable_definition_token2, + STATE(2492), 2, sym_comment, sym_include, - [91834] = 9, - ACTIONS(373), 1, + ACTIONS(3780), 3, + aux_sym__block_terminator_token1, + aux_sym_variable_definition_token1, + aux_sym_method_definition_token1, + [109635] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1078), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2012), 2, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3185), 1, + aux_sym_data_relation_token1, + STATE(2391), 1, + aux_sym_data_relation_repeat1, + STATE(3435), 1, + sym_data_relation, + STATE(2493), 2, sym_comment, sym_include, - [91863] = 8, - ACTIONS(373), 1, + [109661] = 8, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2095), 1, - sym_on_quit_phrase, - STATE(2966), 1, - sym_on_stop_phrase, - ACTIONS(1996), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2013), 2, + ACTIONS(3784), 1, + aux_sym_stream_definition_token1, + ACTIONS(3786), 1, + aux_sym_input_close_statement_token1, + ACTIONS(3788), 1, + aux_sym_input_close_statement_token2, + ACTIONS(3790), 1, + aux_sym_output_stream_statement_token1, + STATE(2494), 2, sym_comment, sym_include, - [91890] = 9, - ACTIONS(373), 1, + [109687] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2020), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2330), 1, - sym_on_stop_phrase, - STATE(2339), 1, - aux_sym_for_statement_repeat1, - STATE(2014), 2, + ACTIONS(3792), 1, + anon_sym_RPAREN, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(2495), 2, sym_comment, sym_include, - [91919] = 9, + [109710] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2908), 1, + ACTIONS(3794), 1, sym_identifier, - ACTIONS(2910), 1, - sym__terminator, - ACTIONS(2912), 1, - anon_sym_NO_DASHERROR, - STATE(1974), 1, - aux_sym_assign_statement_repeat1, - STATE(2283), 1, - sym_assignment, - STATE(2015), 2, + ACTIONS(3796), 1, + aux_sym_input_expression_token2, + STATE(668), 1, + sym_qualified_name, + STATE(2496), 2, sym_comment, sym_include, - [91948] = 9, - ACTIONS(373), 1, + [109733] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1962), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2375), 1, - sym_on_stop_phrase, - STATE(2380), 1, - aux_sym_for_statement_repeat1, - STATE(2016), 2, + STATE(2497), 2, sym_comment, sym_include, - [91977] = 9, - ACTIONS(373), 1, + ACTIONS(1412), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [109752] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2762), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2521), 1, - aux_sym_for_statement_repeat1, - STATE(2528), 1, - sym_on_stop_phrase, - STATE(2017), 2, + STATE(2498), 2, sym_comment, sym_include, - [92006] = 9, - ACTIONS(373), 1, + ACTIONS(3798), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109771] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1968), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 1, - sym_on_stop_phrase, - STATE(2018), 2, + STATE(2499), 2, sym_comment, sym_include, - [92035] = 9, - ACTIONS(373), 1, + ACTIONS(1408), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [109790] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2914), 1, - anon_sym_COLON, - STATE(2098), 1, - sym_on_error_phrase, - STATE(2503), 1, - sym_on_quit_phrase, - STATE(3071), 1, - sym_on_stop_phrase, - STATE(2019), 2, + STATE(2500), 2, sym_comment, sym_include, - [92064] = 9, - ACTIONS(373), 1, + ACTIONS(1402), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [109809] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1168), 1, - sym_do_block, - STATE(1953), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2020), 2, + ACTIONS(3800), 1, + aux_sym__block_terminator_token1, + STATE(1173), 1, + sym__block_terminator, + STATE(1284), 1, + sym__function_terminator, + STATE(2501), 2, sym_comment, sym_include, - [92093] = 9, - ACTIONS(373), 1, + [109832] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2040), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2315), 1, - sym_on_stop_phrase, - STATE(2329), 1, - aux_sym_for_statement_repeat1, - STATE(2021), 2, + STATE(2502), 2, sym_comment, sym_include, - [92122] = 9, - ACTIONS(373), 1, + ACTIONS(1398), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [109851] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1168), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2022), 2, + ACTIONS(3800), 1, + aux_sym__block_terminator_token1, + STATE(1126), 1, + sym__function_terminator, + STATE(1173), 1, + sym__block_terminator, + STATE(2503), 2, sym_comment, sym_include, - [92151] = 9, - ACTIONS(373), 1, + [109874] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2916), 1, - anon_sym_COLON, - STATE(2250), 1, - sym_on_stop_phrase, - STATE(2251), 1, - aux_sym_for_statement_repeat1, - STATE(2023), 2, + STATE(2504), 2, sym_comment, sym_include, - [92180] = 9, - ACTIONS(373), 1, + ACTIONS(3802), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109893] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2764), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2258), 1, - sym_on_stop_phrase, - STATE(2260), 1, - aux_sym_for_statement_repeat1, - STATE(2024), 2, + STATE(2505), 2, sym_comment, sym_include, - [92209] = 9, - ACTIONS(373), 1, + ACTIONS(3804), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109912] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2918), 1, - anon_sym_COLON, - STATE(2261), 1, - sym_on_stop_phrase, - STATE(2263), 1, - aux_sym_for_statement_repeat1, - STATE(2025), 2, + STATE(2506), 2, sym_comment, sym_include, - [92238] = 9, - ACTIONS(373), 1, + ACTIONS(3806), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109931] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2014), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2409), 1, - aux_sym_for_statement_repeat1, - STATE(2411), 1, - sym_on_stop_phrase, - STATE(2026), 2, + STATE(2507), 2, sym_comment, sym_include, - [92267] = 9, - ACTIONS(373), 1, + ACTIONS(3808), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109950] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2024), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2317), 1, - sym_on_stop_phrase, - STATE(2320), 1, - aux_sym_for_statement_repeat1, - STATE(2027), 2, + STATE(2508), 2, sym_comment, sym_include, - [92296] = 9, - ACTIONS(373), 1, + ACTIONS(1398), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [109969] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1045), 1, - sym_do_block, - STATE(2012), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2028), 2, + STATE(2509), 2, sym_comment, sym_include, - [92325] = 8, - ACTIONS(3), 1, + ACTIONS(3810), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [109988] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2863), 1, - sym_identifier, - STATE(1694), 1, - aux_sym_sort_clause_repeat1, - STATE(1894), 1, - sym_sort_column, - STATE(1638), 2, - sym_qualified_name, - sym_function_call, - STATE(2029), 2, + STATE(2510), 2, sym_comment, sym_include, - [92352] = 9, - ACTIONS(373), 1, + ACTIONS(1398), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [110007] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2044), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 1, - sym_on_stop_phrase, - STATE(2030), 2, + STATE(2511), 2, sym_comment, sym_include, - [92381] = 9, - ACTIONS(373), 1, + ACTIONS(3812), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [110026] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1944), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2182), 1, - sym_on_stop_phrase, - STATE(2369), 1, - aux_sym_for_statement_repeat1, - STATE(2031), 2, + STATE(2512), 2, sym_comment, sym_include, - [92410] = 9, + ACTIONS(1398), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [110045] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2908), 1, + ACTIONS(3814), 1, sym_identifier, - ACTIONS(2920), 1, + ACTIONS(3593), 2, sym__terminator, - ACTIONS(2922), 1, - anon_sym_NO_DASHERROR, - STATE(2039), 1, - aux_sym_assign_statement_repeat1, - STATE(2283), 1, - sym_assignment, - STATE(2032), 2, - sym_comment, - sym_include, - [92439] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2776), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2452), 1, - sym_on_stop_phrase, - STATE(2455), 1, - aux_sym_for_statement_repeat1, - STATE(2033), 2, + STATE(2513), 2, sym_comment, sym_include, - [92468] = 9, + [110066] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2908), 1, + ACTIONS(3816), 1, sym_identifier, - ACTIONS(2924), 1, - sym__terminator, - ACTIONS(2926), 1, - anon_sym_NO_DASHERROR, - STATE(2015), 1, - aux_sym_assign_statement_repeat1, - STATE(2283), 1, - sym_assignment, - STATE(2034), 2, + ACTIONS(3818), 1, + aux_sym_buffer_definition_token3, + STATE(3570), 1, + sym_qualified_name, + STATE(2514), 2, sym_comment, sym_include, - [92497] = 9, - ACTIONS(373), 1, + [110089] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2724), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2426), 1, - sym_on_stop_phrase, - STATE(2457), 1, - aux_sym_for_statement_repeat1, - STATE(2035), 2, + STATE(2515), 2, sym_comment, sym_include, - [92526] = 9, - ACTIONS(373), 1, + ACTIONS(1394), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [110108] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3820), 1, + anon_sym_RPAREN, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2392), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2267), 1, - sym_on_stop_phrase, - STATE(2269), 1, - aux_sym_for_statement_repeat1, - STATE(2036), 2, - sym_comment, - sym_include, - [92555] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2928), 1, - anon_sym_COLON, - STATE(2105), 1, - sym_on_error_phrase, - STATE(2456), 1, - sym_on_quit_phrase, - STATE(3206), 1, - sym_on_stop_phrase, - STATE(2037), 2, - sym_comment, - sym_include, - [92584] = 9, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2930), 1, - anon_sym_COLON, - STATE(2175), 1, - sym_on_error_phrase, - STATE(2307), 1, - sym_on_quit_phrase, - STATE(3047), 1, - sym_on_stop_phrase, - STATE(2038), 2, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2516), 2, sym_comment, sym_include, - [92613] = 9, + [110131] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2908), 1, + ACTIONS(3824), 1, sym_identifier, - ACTIONS(2932), 1, - sym__terminator, - ACTIONS(2934), 1, - anon_sym_NO_DASHERROR, - STATE(1974), 1, - aux_sym_assign_statement_repeat1, - STATE(2283), 1, - sym_assignment, - STATE(2039), 2, - sym_comment, - sym_include, - [92642] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2936), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2940), 1, - aux_sym_on_error_phrase_token8, - STATE(2040), 2, + ACTIONS(3826), 1, + aux_sym_class_statement_token1, + STATE(3722), 1, + sym_qualified_name, + STATE(2517), 2, sym_comment, sym_include, - ACTIONS(2938), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [92667] = 8, - ACTIONS(373), 1, + [110154] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2101), 1, - sym_on_quit_phrase, - STATE(2962), 1, - sym_on_stop_phrase, - ACTIONS(2066), 2, + ACTIONS(3822), 1, anon_sym_COMMA, - anon_sym_COLON, - STATE(2041), 2, + ACTIONS(3828), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2518), 2, sym_comment, sym_include, - [92694] = 9, - ACTIONS(373), 1, + [110177] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2752), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2272), 1, - sym_on_stop_phrase, - STATE(2274), 1, - aux_sym_for_statement_repeat1, - STATE(2042), 2, + STATE(2519), 2, sym_comment, sym_include, - [92723] = 9, - ACTIONS(373), 1, + ACTIONS(3830), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [110196] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1045), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2043), 2, + ACTIONS(3832), 1, + sym_identifier, + ACTIONS(3834), 1, + anon_sym_AMP, + ACTIONS(3836), 1, + sym__integer_literal, + STATE(2520), 2, sym_comment, sym_include, - [92752] = 9, - ACTIONS(373), 1, + [110219] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2942), 1, + ACTIONS(3838), 1, + sym_identifier, + ACTIONS(3525), 2, + sym__terminator, anon_sym_COLON, - STATE(2148), 1, - sym_on_error_phrase, - STATE(2216), 1, - sym_on_quit_phrase, - STATE(3207), 1, - sym_on_stop_phrase, - STATE(2044), 2, + STATE(2521), 2, sym_comment, sym_include, - [92781] = 9, - ACTIONS(373), 1, + [110240] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2373), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2332), 1, - sym_on_stop_phrase, - STATE(2384), 1, - aux_sym_for_statement_repeat1, - STATE(2045), 2, + STATE(2522), 2, sym_comment, sym_include, - [92810] = 9, - ACTIONS(373), 1, + ACTIONS(3840), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [110259] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2048), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2305), 1, - aux_sym_for_statement_repeat1, - STATE(2306), 1, - sym_on_stop_phrase, - STATE(2046), 2, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(3842), 1, + sym_identifier, + ACTIONS(3844), 1, + aux_sym_input_expression_token2, + STATE(561), 1, + sym_qualified_name, + STATE(2523), 2, sym_comment, sym_include, - [92839] = 7, - ACTIONS(373), 1, + [110282] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2944), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2948), 1, - aux_sym_on_error_phrase_token8, - STATE(2047), 2, + ACTIONS(3846), 1, + aux_sym_buffer_definition_token2, + ACTIONS(3848), 1, + aux_sym_repeat_statement_token1, + ACTIONS(3850), 1, + aux_sym_do_while_statement_token1, + STATE(2524), 2, sym_comment, sym_include, - ACTIONS(2946), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [92864] = 8, - ACTIONS(373), 1, + [110305] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2143), 1, - sym_on_quit_phrase, - STATE(2929), 1, - sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2048), 2, + ACTIONS(3852), 1, + aux_sym__block_terminator_token1, + STATE(1212), 2, + sym__block_terminator, + sym__procedure_terminator, + STATE(2525), 2, sym_comment, sym_include, - [92891] = 6, + [110326] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2952), 1, - aux_sym_widget_field_token1, - STATE(2049), 2, + ACTIONS(671), 1, + anon_sym_LPAREN, + ACTIONS(3854), 1, + sym_identifier, + STATE(550), 1, + sym_parenthesized_expression, + STATE(2526), 2, sym_comment, sym_include, - ACTIONS(2950), 4, - sym_identifier, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - aux_sym_field_definition_token1, - [92914] = 9, - ACTIONS(373), 1, + [110349] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1982), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3856), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2489), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 1, - sym_on_stop_phrase, - STATE(2050), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2527), 2, sym_comment, sym_include, - [92943] = 9, - ACTIONS(373), 1, + [110372] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2000), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3858), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2419), 1, - sym_on_stop_phrase, - STATE(2420), 1, - aux_sym_for_statement_repeat1, - STATE(2051), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2528), 2, sym_comment, sym_include, - [92972] = 9, - ACTIONS(373), 1, + [110395] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, + ACTIONS(3860), 1, + aux_sym_buffer_definition_token2, + ACTIONS(3862), 1, + aux_sym_repeat_statement_token1, + ACTIONS(3864), 1, aux_sym_do_while_statement_token1, - STATE(1351), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2052), 2, + STATE(2529), 2, sym_comment, sym_include, - [93001] = 9, - ACTIONS(373), 1, + [110418] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(980), 1, + ACTIONS(3866), 1, + sym_identifier, + ACTIONS(3868), 1, aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1351), 1, - sym_do_block, - STATE(2076), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2053), 2, + STATE(339), 1, + sym_qualified_name, + STATE(2530), 2, sym_comment, sym_include, - [93030] = 5, - ACTIONS(373), 1, + [110441] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2054), 2, + ACTIONS(3870), 1, + aux_sym__block_terminator_token1, + STATE(1311), 2, + sym__block_terminator, + sym__procedure_terminator, + STATE(2531), 2, sym_comment, sym_include, - ACTIONS(2954), 5, - sym__terminator, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - aux_sym_query_definition_token3, - [93051] = 9, - ACTIONS(373), 1, + [110462] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2022), 1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(3341), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2282), 1, - sym_on_stop_phrase, - STATE(2284), 1, - aux_sym_for_statement_repeat1, - STATE(2055), 2, + STATE(3708), 1, + sym_inherits, + STATE(2532), 2, sym_comment, sym_include, - [93080] = 7, - ACTIONS(373), 1, + [110485] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2956), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2960), 1, - aux_sym_on_error_phrase_token8, - STATE(2056), 2, + ACTIONS(3872), 1, + aux_sym_on_error_phrase_token2, + ACTIONS(3874), 1, + aux_sym_on_stop_phrase_token1, + ACTIONS(3876), 1, + aux_sym_on_quit_phrase_token1, + STATE(2533), 2, sym_comment, sym_include, - ACTIONS(2958), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [93105] = 9, - ACTIONS(373), 1, + [110508] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2377), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2515), 1, - sym_on_stop_phrase, + ACTIONS(3878), 1, + anon_sym_RPAREN, STATE(2516), 1, - aux_sym_for_statement_repeat1, - STATE(2057), 2, + aux_sym_function_statement_repeat1, + STATE(2534), 2, sym_comment, sym_include, - [93134] = 9, - ACTIONS(373), 1, + [110531] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2402), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2290), 1, + ACTIONS(3880), 1, + anon_sym_COLON, + STATE(3406), 1, sym_on_stop_phrase, - STATE(2291), 1, - aux_sym_for_statement_repeat1, - STATE(2058), 2, + STATE(2535), 2, sym_comment, sym_include, - [93163] = 7, - ACTIONS(373), 1, + [110554] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2962), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2966), 1, - aux_sym_on_error_phrase_token8, - STATE(2059), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3882), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2536), 2, sym_comment, sym_include, - ACTIONS(2964), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [93188] = 9, - ACTIONS(373), 1, + [110577] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2398), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2388), 1, - aux_sym_for_statement_repeat1, - STATE(2394), 1, - sym_on_stop_phrase, - STATE(2060), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1712), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2537), 2, sym_comment, sym_include, - [93217] = 9, - ACTIONS(373), 1, + [110600] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2050), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2530), 1, - aux_sym_for_statement_repeat1, - STATE(2553), 1, - sym_on_stop_phrase, - STATE(2061), 2, + ACTIONS(3886), 1, + sym_identifier, + ACTIONS(3888), 1, + anon_sym_AMP, + ACTIONS(3890), 1, + sym__integer_literal, + STATE(2538), 2, sym_comment, sym_include, - [93246] = 9, - ACTIONS(373), 1, + [110623] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3892), 1, + anon_sym_RPAREN, + ACTIONS(3894), 1, anon_sym_COMMA, - ACTIONS(2375), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2257), 1, - sym_on_stop_phrase, - STATE(2285), 1, - aux_sym_for_statement_repeat1, - STATE(2062), 2, + STATE(2657), 1, + aux_sym__function_call_arguments_repeat1, + STATE(2539), 2, sym_comment, sym_include, - [93275] = 9, - ACTIONS(373), 1, + [110646] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(140), 1, + anon_sym_LPAREN, + ACTIONS(3896), 1, + sym_identifier, + STATE(326), 1, + sym_parenthesized_expression, + STATE(2540), 2, + sym_comment, + sym_include, + [110669] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1986), 1, + ACTIONS(3322), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2221), 1, + STATE(2905), 1, aux_sym_for_statement_repeat1, - STATE(2294), 1, - sym_on_stop_phrase, - STATE(2063), 2, + STATE(2541), 2, sym_comment, sym_include, - [93304] = 9, - ACTIONS(373), 1, + [110692] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1190), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2968), 1, - anon_sym_COLON, - STATE(2094), 1, - sym_on_error_phrase, - STATE(2522), 1, - sym_on_quit_phrase, - STATE(3224), 1, - sym_on_stop_phrase, - STATE(2064), 2, + ACTIONS(3898), 1, + sym_identifier, + ACTIONS(3900), 1, + aux_sym_input_expression_token2, + STATE(339), 1, + sym_qualified_name, + STATE(2542), 2, + sym_comment, + sym_include, + [110715] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(788), 1, + anon_sym_LPAREN, + ACTIONS(3902), 1, + sym_identifier, + STATE(802), 1, + sym_parenthesized_expression, + STATE(2543), 2, sym_comment, sym_include, - [93333] = 9, - ACTIONS(373), 1, + [110738] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2008), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2308), 1, - sym_on_stop_phrase, - STATE(2310), 1, - aux_sym_for_statement_repeat1, - STATE(2065), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3904), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2544), 2, sym_comment, sym_include, - [93362] = 9, - ACTIONS(373), 1, + [110761] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3906), 1, + sym_identifier, + ACTIONS(3908), 1, + anon_sym_AMP, + ACTIONS(3910), 1, + sym__integer_literal, + STATE(2545), 2, + sym_comment, + sym_include, + [110784] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(2970), 1, + ACTIONS(3912), 1, anon_sym_COLON, - STATE(2547), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2548), 1, - sym_on_stop_phrase, - STATE(2066), 2, + STATE(2546), 2, sym_comment, sym_include, - [93391] = 9, - ACTIONS(373), 1, + [110807] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1966), 1, + ACTIONS(3914), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2510), 1, + STATE(2546), 1, aux_sym_for_statement_repeat1, - STATE(2552), 1, - sym_on_stop_phrase, - STATE(2067), 2, + STATE(2547), 2, sym_comment, sym_include, - [93420] = 9, - ACTIONS(373), 1, + [110830] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1946), 1, + ACTIONS(3914), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2377), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2492), 1, - sym_on_stop_phrase, - STATE(2068), 2, + STATE(2548), 2, sym_comment, sym_include, - [93449] = 7, - ACTIONS(373), 1, + [110853] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2886), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2890), 1, - aux_sym_on_error_phrase_token8, - STATE(2069), 2, + STATE(2549), 2, sym_comment, sym_include, - ACTIONS(2972), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [93474] = 9, - ACTIONS(373), 1, + ACTIONS(1388), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [110872] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1990), 1, + ACTIONS(3916), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2237), 1, - sym_on_stop_phrase, - STATE(2276), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2070), 2, + STATE(2550), 2, sym_comment, sym_include, - [93503] = 9, - ACTIONS(373), 1, + [110895] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1085), 1, - sym_do_block, - STATE(2022), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2071), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3345), 1, + anon_sym_COLON, + STATE(2548), 1, + aux_sym_for_statement_repeat1, + STATE(2551), 2, sym_comment, sym_include, - [93532] = 9, - ACTIONS(373), 1, + [110918] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2018), 1, + ACTIONS(3345), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2193), 1, - sym_on_stop_phrase, - STATE(2196), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2072), 2, + STATE(2552), 2, sym_comment, sym_include, - [93561] = 9, - ACTIONS(373), 1, + [110941] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(988), 1, - aux_sym_do_while_statement_token1, - STATE(1085), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2073), 2, + STATE(2553), 2, sym_comment, sym_include, - [93590] = 7, - ACTIONS(373), 1, + ACTIONS(1388), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [110960] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2944), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(2948), 1, - aux_sym_on_error_phrase_token8, - STATE(2074), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3918), 1, + anon_sym_COLON, + STATE(2550), 1, + aux_sym_for_statement_repeat1, + STATE(2554), 2, sym_comment, sym_include, - ACTIONS(2974), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [93615] = 9, - ACTIONS(373), 1, + [110983] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1974), 1, + ACTIONS(3918), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2430), 1, - sym_on_stop_phrase, - STATE(2557), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2075), 2, + STATE(2555), 2, sym_comment, sym_include, - [93644] = 9, - ACTIONS(373), 1, + [111006] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, - aux_sym_do_while_statement_token1, - STATE(1380), 1, - sym_do_block, - STATE(2159), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2076), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2106), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2556), 2, sym_comment, sym_include, - [93673] = 9, - ACTIONS(373), 1, + [111029] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(980), 1, - aux_sym_input_expression_token2, - ACTIONS(984), 1, + ACTIONS(3920), 1, + aux_sym_buffer_definition_token2, + ACTIONS(3922), 1, + aux_sym_repeat_statement_token1, + ACTIONS(3924), 1, aux_sym_do_while_statement_token1, - STATE(1380), 1, - sym_do_block, - STATE(2007), 1, - aux_sym_on_statement_repeat2, - STATE(2831), 1, - sym_widget_phrase, - STATE(2077), 2, + STATE(2557), 2, sym_comment, sym_include, - [93702] = 8, - ACTIONS(373), 1, + [111052] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2681), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3264), 1, anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2323), 1, - sym_on_quit_phrase, - STATE(3204), 1, - sym_on_stop_phrase, - STATE(2078), 2, - sym_comment, - sym_include, - [93728] = 7, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(2976), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2079), 2, - sym_comment, - sym_include, - [93752] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2980), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2080), 2, + STATE(2552), 1, + aux_sym_for_statement_repeat1, + STATE(2558), 2, sym_comment, sym_include, - ACTIONS(2982), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [93774] = 6, - ACTIONS(3), 1, + [111075] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2987), 1, - anon_sym_SQUOTE, - ACTIONS(2984), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2081), 3, + STATE(2559), 2, sym_comment, sym_include, - aux_sym_single_quoted_string_repeat1, - [93796] = 5, - ACTIONS(373), 1, + ACTIONS(1388), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111094] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2082), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3264), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2560), 2, sym_comment, sym_include, - ACTIONS(2989), 4, - sym__terminator, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - [93816] = 5, - ACTIONS(373), 1, + [111117] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2083), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3347), 1, + anon_sym_COLON, + STATE(2555), 1, + aux_sym_for_statement_repeat1, + STATE(2561), 2, sym_comment, sym_include, - ACTIONS(2991), 4, - sym__terminator, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - [93836] = 7, - ACTIONS(373), 1, + [111140] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2929), 1, - sym_on_stop_phrase, - ACTIONS(1970), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2084), 2, + STATE(2562), 2, sym_comment, sym_include, - [93860] = 8, - ACTIONS(373), 1, + ACTIONS(1388), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111159] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2993), 1, - aux_sym_do_statement_token1, - ACTIONS(2995), 1, - aux_sym_stream_definition_token1, - ACTIONS(2997), 1, - aux_sym_input_close_statement_token1, - ACTIONS(2999), 1, - aux_sym_input_close_statement_token2, - STATE(2085), 2, + STATE(2563), 2, sym_comment, sym_include, - [93886] = 8, - ACTIONS(373), 1, + ACTIONS(1384), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111178] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3001), 1, - aux_sym_stream_definition_token1, - ACTIONS(3003), 1, - aux_sym_input_close_statement_token1, - ACTIONS(3005), 1, - aux_sym_input_close_statement_token2, - ACTIONS(3007), 1, - aux_sym_input_stream_statement_token1, - STATE(2086), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3347), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2564), 2, sym_comment, sym_include, - [93912] = 7, - ACTIONS(3), 1, + [111201] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3009), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2087), 2, + STATE(2565), 2, sym_comment, sym_include, - [93936] = 8, - ACTIONS(373), 1, + ACTIONS(1380), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111220] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3011), 1, - aux_sym_stream_definition_token1, - ACTIONS(3013), 1, - aux_sym_input_close_statement_token1, - ACTIONS(3015), 1, - aux_sym_input_close_statement_token2, - ACTIONS(3017), 1, - aux_sym_input_stream_statement_token1, - STATE(2088), 2, + STATE(2566), 2, sym_comment, sym_include, - [93962] = 5, - ACTIONS(373), 1, + ACTIONS(1376), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111239] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2089), 2, + STATE(2567), 2, sym_comment, sym_include, - ACTIONS(3019), 4, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [93982] = 8, - ACTIONS(373), 1, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111258] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2639), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2106), 1, anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2520), 1, - sym_on_quit_phrase, - STATE(3222), 1, - sym_on_stop_phrase, - STATE(2090), 2, + STATE(2624), 1, + aux_sym_for_statement_repeat1, + STATE(2568), 2, sym_comment, sym_include, - [94008] = 7, - ACTIONS(3), 1, + [111281] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3021), 1, - anon_sym_DQUOTE, - STATE(2087), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2091), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3322), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2569), 2, sym_comment, sym_include, - [94032] = 8, - ACTIONS(373), 1, + [111304] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3023), 1, - aux_sym_do_statement_token1, - ACTIONS(3025), 1, - aux_sym_stream_definition_token1, - ACTIONS(3027), 1, - aux_sym_input_close_statement_token1, - ACTIONS(3029), 1, - aux_sym_input_close_statement_token2, - STATE(2092), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2056), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2570), 2, sym_comment, sym_include, - [94058] = 7, - ACTIONS(3), 1, + [111327] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3031), 1, - sym_identifier, - STATE(269), 1, - sym_qualified_name, - ACTIONS(3033), 2, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - STATE(2093), 2, + STATE(2571), 2, sym_comment, sym_include, - [94082] = 8, - ACTIONS(373), 1, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111346] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3035), 1, - anon_sym_COLON, - STATE(2484), 1, - sym_on_quit_phrase, - STATE(3215), 1, - sym_on_stop_phrase, - STATE(2094), 2, + ACTIONS(3822), 1, + anon_sym_COMMA, + ACTIONS(3926), 1, + anon_sym_RPAREN, + STATE(2788), 1, + aux_sym_function_statement_repeat1, + STATE(2572), 2, sym_comment, sym_include, - [94108] = 7, - ACTIONS(373), 1, + [111369] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2962), 1, - sym_on_stop_phrase, - ACTIONS(2066), 2, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2756), 1, anon_sym_COLON, - STATE(2095), 2, + STATE(2560), 1, + aux_sym_for_statement_repeat1, + STATE(2573), 2, sym_comment, sym_include, - [94132] = 8, - ACTIONS(373), 1, + [111392] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3037), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2756), 1, anon_sym_COLON, - STATE(2454), 1, - sym_on_quit_phrase, - STATE(3211), 1, - sym_on_stop_phrase, - STATE(2096), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2574), 2, sym_comment, sym_include, - [94158] = 6, - ACTIONS(3), 1, + [111415] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3039), 1, - sym_identifier, - STATE(2097), 2, + STATE(2575), 2, sym_comment, sym_include, - ACTIONS(3041), 3, + ACTIONS(1990), 3, + aux_sym_buffer_definition_token2, + aux_sym_repeat_statement_token1, + aux_sym_do_while_statement_token1, + [111434] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(3258), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94180] = 8, - ACTIONS(373), 1, + STATE(2564), 1, + aux_sym_for_statement_repeat1, + STATE(2576), 2, + sym_comment, + sym_include, + [111457] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3043), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3258), 1, anon_sym_COLON, - STATE(2254), 1, - sym_on_quit_phrase, - STATE(3092), 1, - sym_on_stop_phrase, - STATE(2098), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2577), 2, sym_comment, sym_include, - [94206] = 5, - ACTIONS(373), 1, + [111480] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2099), 2, + STATE(2578), 2, sym_comment, sym_include, - ACTIONS(3045), 4, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94226] = 8, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111499] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2433), 1, - sym_identifier, - ACTIONS(2437), 1, - aux_sym__while_condition_token1, - STATE(3219), 1, - sym__while_condition, - STATE(3245), 1, - sym_assignment, - STATE(2100), 2, + ACTIONS(3928), 1, + anon_sym_RPAREN, + ACTIONS(3930), 1, + anon_sym_, + STATE(2579), 3, sym_comment, sym_include, - [94252] = 7, - ACTIONS(373), 1, + aux_sym_accumulate_statement_repeat1, + [111520] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2957), 1, - sym_on_stop_phrase, - ACTIONS(2068), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2101), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1708), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2580), 2, sym_comment, sym_include, - [94276] = 6, - ACTIONS(373), 1, + [111543] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2801), 1, - sym_for_phrase, - STATE(2102), 2, + STATE(2581), 2, sym_comment, sym_include, - ACTIONS(3047), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [94298] = 7, - ACTIONS(3), 1, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111562] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3049), 1, - anon_sym_DQUOTE, - STATE(2166), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2103), 2, + STATE(2582), 2, sym_comment, sym_include, - [94322] = 6, - ACTIONS(3), 1, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111581] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3051), 1, - sym_identifier, - STATE(2104), 2, - sym_comment, - sym_include, - ACTIONS(3053), 3, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2056), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94344] = 8, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3055), 1, - anon_sym_COLON, - STATE(2396), 1, - sym_on_quit_phrase, - STATE(3159), 1, - sym_on_stop_phrase, - STATE(2105), 2, + STATE(2648), 1, + aux_sym_for_statement_repeat1, + STATE(2583), 2, sym_comment, sym_include, - [94370] = 7, - ACTIONS(3), 1, + [111604] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3059), 1, - anon_sym_SQUOTE, - STATE(2167), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2106), 2, + STATE(2584), 2, sym_comment, sym_include, - [94394] = 5, - ACTIONS(3), 1, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111623] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2107), 2, + STATE(2585), 2, sym_comment, sym_include, - ACTIONS(3061), 4, - sym_identifier, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - aux_sym_field_definition_token1, - [94414] = 6, - ACTIONS(3), 1, + ACTIONS(1374), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111642] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3063), 1, - anon_sym_DQUOTE, - ACTIONS(3065), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2108), 3, + STATE(2586), 2, sym_comment, sym_include, - aux_sym_double_quoted_string_repeat1, - [94436] = 7, - ACTIONS(3), 1, + ACTIONS(1370), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111661] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3068), 1, - anon_sym_SQUOTE, - STATE(2081), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2109), 2, + STATE(2587), 2, sym_comment, sym_include, - [94460] = 7, - ACTIONS(3), 1, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111680] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3070), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2110), 2, + STATE(2588), 2, sym_comment, sym_include, - [94484] = 7, - ACTIONS(373), 1, + ACTIONS(1366), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111699] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2954), 1, - sym_on_stop_phrase, - ACTIONS(2443), 2, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2130), 1, anon_sym_COLON, - STATE(2111), 2, + STATE(2574), 1, + aux_sym_for_statement_repeat1, + STATE(2589), 2, sym_comment, sym_include, - [94508] = 8, - ACTIONS(373), 1, + [111722] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(982), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3072), 1, - aux_sym_of_token1, - ACTIONS(3074), 1, - aux_sym_on_statement_token1, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2112), 2, + ACTIONS(2130), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2590), 2, sym_comment, sym_include, - [94534] = 7, - ACTIONS(3), 1, + [111745] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3076), 1, - anon_sym_SQUOTE, - STATE(2109), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2113), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2758), 1, + anon_sym_COLON, + STATE(2577), 1, + aux_sym_for_statement_repeat1, + STATE(2591), 2, sym_comment, sym_include, - [94558] = 7, - ACTIONS(3), 1, + [111768] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3078), 1, - anon_sym_DQUOTE, - STATE(2110), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2114), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2758), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2592), 2, sym_comment, sym_include, - [94582] = 8, - ACTIONS(373), 1, + [111791] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3080), 1, - anon_sym_COLON, - STATE(2497), 1, - sym_on_quit_phrase, - STATE(3067), 1, - sym_on_stop_phrase, - STATE(2115), 2, + ACTIONS(3149), 1, + aux_sym__block_terminator_token1, + STATE(1369), 1, + sym__case_terminator, + STATE(1452), 1, + sym__block_terminator, + STATE(2593), 2, sym_comment, sym_include, - [94608] = 5, - ACTIONS(3), 1, + [111814] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2116), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2132), 1, + anon_sym_COLON, + STATE(2590), 1, + aux_sym_for_statement_repeat1, + STATE(2594), 2, sym_comment, sym_include, - ACTIONS(3082), 4, - sym_identifier, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - aux_sym_field_definition_token1, - [94628] = 6, - ACTIONS(373), 1, + [111837] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3084), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2117), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2132), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2595), 2, sym_comment, sym_include, - ACTIONS(3086), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [94650] = 7, - ACTIONS(373), 1, + [111860] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2950), 1, - sym_on_stop_phrase, - ACTIONS(2896), 2, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2164), 1, anon_sym_COLON, - STATE(2118), 2, + STATE(2592), 1, + aux_sym_for_statement_repeat1, + STATE(2596), 2, sym_comment, sym_include, - [94674] = 7, - ACTIONS(373), 1, + [111883] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(2947), 1, - sym_on_stop_phrase, - ACTIONS(3088), 2, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2164), 1, anon_sym_COLON, - STATE(2119), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2597), 2, sym_comment, sym_include, - [94698] = 5, - ACTIONS(3), 1, + [111906] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(510), 1, - sym_identifier, - STATE(2120), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2100), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2598), 2, sym_comment, sym_include, - ACTIONS(508), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [94718] = 6, - ACTIONS(3), 1, + [111929] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3090), 1, - sym_identifier, - STATE(2121), 2, - sym_comment, - sym_include, - ACTIONS(3092), 3, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2100), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94740] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(2122), 2, + STATE(2595), 1, + aux_sym_for_statement_repeat1, + STATE(2599), 2, sym_comment, sym_include, - ACTIONS(3094), 4, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94760] = 8, - ACTIONS(373), 1, + [111952] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(982), 1, - anon_sym_COMMA, - ACTIONS(3096), 1, - aux_sym_of_token1, - ACTIONS(3098), 1, - aux_sym_on_statement_token1, - STATE(1833), 1, - aux_sym_on_statement_repeat1, - STATE(2123), 2, + STATE(2600), 2, sym_comment, sym_include, - [94786] = 5, - ACTIONS(373), 1, + ACTIONS(1362), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111971] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2124), 2, + STATE(2601), 2, sym_comment, sym_include, - ACTIONS(3100), 4, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94806] = 5, - ACTIONS(373), 1, + ACTIONS(3933), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [111990] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2125), 2, + ACTIONS(3870), 1, + aux_sym__block_terminator_token1, + STATE(1386), 2, + sym__block_terminator, + sym__procedure_terminator, + STATE(2602), 2, sym_comment, sym_include, - ACTIONS(3102), 4, - sym__terminator, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94826] = 7, - ACTIONS(3), 1, + [112011] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3104), 1, - anon_sym_SQUOTE, - STATE(2081), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2126), 2, + STATE(2603), 2, sym_comment, sym_include, - [94850] = 7, - ACTIONS(3), 1, + ACTIONS(1358), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112030] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3106), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2127), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2142), 1, + anon_sym_COLON, + STATE(2597), 1, + aux_sym_for_statement_repeat1, + STATE(2604), 2, sym_comment, sym_include, - [94874] = 6, - ACTIONS(373), 1, + [112053] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2980), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2128), 2, + STATE(2605), 2, sym_comment, - sym_include, - ACTIONS(3108), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [94896] = 6, - ACTIONS(3), 1, + sym_include, + ACTIONS(1354), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112072] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3110), 1, - sym_identifier, - STATE(2129), 2, + STATE(2606), 2, sym_comment, sym_include, - ACTIONS(3112), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [94918] = 6, - ACTIONS(373), 1, + ACTIONS(1354), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112091] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3114), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2130), 2, + STATE(2607), 2, sym_comment, sym_include, - ACTIONS(3116), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [94940] = 7, - ACTIONS(3), 1, + ACTIONS(1354), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112110] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3118), 1, - anon_sym_SQUOTE, - STATE(2126), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2131), 2, + STATE(2608), 2, sym_comment, sym_include, - [94964] = 7, - ACTIONS(3), 1, + ACTIONS(1354), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112129] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3120), 1, - anon_sym_DQUOTE, - STATE(2127), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2132), 2, + STATE(2609), 2, sym_comment, sym_include, - [94988] = 6, - ACTIONS(373), 1, + ACTIONS(1350), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112148] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3122), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2133), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3935), 1, + anon_sym_COLON, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2610), 2, sym_comment, sym_include, - ACTIONS(3124), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [95010] = 5, - ACTIONS(373), 1, + [112171] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2134), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2142), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2611), 2, sym_comment, sym_include, - ACTIONS(3126), 4, - sym__terminator, - aux_sym_query_definition_tuning_token1, - anon_sym_SCROLLING, - aux_sym_query_definition_tuning_token2, - [95030] = 8, - ACTIONS(373), 1, + [112194] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3128), 1, + ACTIONS(3937), 1, anon_sym_COLON, - STATE(2203), 1, - sym_on_quit_phrase, - STATE(3135), 1, + STATE(3615), 1, sym_on_stop_phrase, - STATE(2135), 2, + STATE(2612), 2, sym_comment, sym_include, - [95056] = 5, - ACTIONS(3), 1, + [112217] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2136), 2, + STATE(2613), 2, sym_comment, sym_include, - ACTIONS(3130), 4, - sym_identifier, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, + ACTIONS(3939), 3, + sym__terminator, aux_sym_field_definition_token1, - [95076] = 7, - ACTIONS(3), 1, + aux_sym_index_definition_token1, + [112236] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3132), 1, - sym_identifier, - STATE(271), 1, - sym_qualified_name, - ACTIONS(3134), 2, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - STATE(2137), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2614), 2, sym_comment, sym_include, - [95100] = 8, - ACTIONS(373), 1, + [112259] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3136), 1, - anon_sym_COLON, - STATE(2483), 1, - sym_on_quit_phrase, - STATE(2975), 1, - sym_on_stop_phrase, - STATE(2138), 2, + STATE(2615), 2, sym_comment, sym_include, - [95126] = 7, - ACTIONS(3), 1, + ACTIONS(3941), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112278] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3138), 1, - sym_identifier, - STATE(266), 1, - sym_qualified_name, - ACTIONS(3140), 2, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - STATE(2139), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3943), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2616), 2, sym_comment, sym_include, - [95150] = 5, - ACTIONS(3), 1, + [112301] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(398), 1, - sym_identifier, - STATE(2140), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2048), 1, + anon_sym_COLON, + STATE(2598), 1, + aux_sym_for_statement_repeat1, + STATE(2617), 2, sym_comment, sym_include, - ACTIONS(396), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95170] = 5, - ACTIONS(3), 1, + [112324] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2141), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2086), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2618), 2, sym_comment, sym_include, - ACTIONS(2786), 4, - sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [95190] = 8, - ACTIONS(373), 1, + [112347] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2679), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2086), 1, anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2319), 1, - sym_on_quit_phrase, - STATE(3049), 1, - sym_on_stop_phrase, - STATE(2142), 2, + STATE(2611), 1, + aux_sym_for_statement_repeat1, + STATE(2619), 2, sym_comment, sym_include, - [95216] = 7, - ACTIONS(373), 1, + [112370] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2966), 1, - sym_on_stop_phrase, - ACTIONS(1996), 2, - anon_sym_COMMA, + ACTIONS(3945), 1, anon_sym_COLON, - STATE(2143), 2, + STATE(3598), 1, + sym_on_stop_phrase, + STATE(2620), 2, sym_comment, sym_include, - [95240] = 7, - ACTIONS(3), 1, + [112393] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3142), 1, - anon_sym_DQUOTE, - STATE(2153), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2144), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3947), 1, + anon_sym_COLON, + STATE(3597), 1, + sym_on_stop_phrase, + STATE(2621), 2, sym_comment, sym_include, - [95264] = 7, - ACTIONS(3), 1, + [112416] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3144), 1, - anon_sym_SQUOTE, - STATE(2155), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2145), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3949), 1, + anon_sym_COLON, + STATE(3584), 1, + sym_on_stop_phrase, + STATE(2622), 2, sym_comment, sym_include, - [95288] = 5, - ACTIONS(3), 1, + [112439] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2146), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2623), 2, sym_comment, sym_include, - ACTIONS(2810), 4, - sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [95308] = 5, - ACTIONS(3), 1, + [112462] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2147), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2166), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2624), 2, sym_comment, sym_include, - ACTIONS(2806), 4, - sym_identifier, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [95328] = 8, - ACTIONS(373), 1, + [112485] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3146), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2166), 1, anon_sym_COLON, - STATE(2390), 1, - sym_on_quit_phrase, - STATE(3138), 1, - sym_on_stop_phrase, - STATE(2148), 2, + STATE(2862), 1, + aux_sym_for_statement_repeat1, + STATE(2625), 2, sym_comment, sym_include, - [95354] = 8, - ACTIONS(3), 1, + [112508] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2433), 1, - sym_identifier, - ACTIONS(2437), 1, - aux_sym__while_condition_token1, - STATE(3166), 1, - sym__while_condition, - STATE(3167), 1, - sym_assignment, - STATE(2149), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2060), 1, + anon_sym_COLON, + STATE(2618), 1, + aux_sym_for_statement_repeat1, + STATE(2626), 2, sym_comment, sym_include, - [95380] = 5, - ACTIONS(3), 1, + [112531] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(3148), 1, - sym_identifier, - STATE(2150), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2627), 2, sym_comment, sym_include, - ACTIONS(3150), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95400] = 5, - ACTIONS(3), 1, + ACTIONS(1532), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112550] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(3152), 1, - sym_identifier, - STATE(2151), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2628), 2, sym_comment, sym_include, - ACTIONS(3154), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95420] = 8, - ACTIONS(373), 1, + ACTIONS(1346), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112569] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3156), 1, - anon_sym_COLON, - STATE(2341), 1, - sym_on_quit_phrase, - STATE(2984), 1, - sym_on_stop_phrase, - STATE(2152), 2, + STATE(2629), 2, sym_comment, sym_include, - [95446] = 7, - ACTIONS(3), 1, + ACTIONS(1342), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112588] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3158), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2153), 2, + STATE(2630), 2, sym_comment, sym_include, - [95470] = 5, - ACTIONS(3), 1, + ACTIONS(1338), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112607] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(3160), 1, - sym_identifier, - STATE(2154), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2631), 2, sym_comment, sym_include, - ACTIONS(3162), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95490] = 7, - ACTIONS(3), 1, + ACTIONS(1334), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [112626] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3164), 1, - anon_sym_SQUOTE, - STATE(2081), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2155), 2, + ACTIONS(3800), 1, + aux_sym__block_terminator_token1, + STATE(1173), 1, + sym__block_terminator, + STATE(1177), 1, + sym__function_terminator, + STATE(2632), 2, sym_comment, sym_include, - [95514] = 8, - ACTIONS(373), 1, + [112649] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2643), 1, - anon_sym_COLON, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(2212), 1, - sym_on_quit_phrase, - STATE(3119), 1, + ACTIONS(3467), 1, + anon_sym_COLON, + STATE(3566), 1, sym_on_stop_phrase, - STATE(2156), 2, + STATE(2633), 2, sym_comment, sym_include, - [95540] = 8, - ACTIONS(373), 1, + [112672] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3166), 1, + ACTIONS(3951), 1, anon_sym_COLON, - STATE(2304), 1, - sym_on_quit_phrase, - STATE(3084), 1, + STATE(3565), 1, sym_on_stop_phrase, - STATE(2157), 2, + STATE(2634), 2, sym_comment, sym_include, - [95566] = 5, + [112695] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(3168), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(3953), 1, sym_identifier, - STATE(2158), 2, + ACTIONS(3955), 1, + aux_sym_buffer_definition_token3, + STATE(3606), 1, + sym_qualified_name, + STATE(2635), 2, sym_comment, sym_include, - ACTIONS(3170), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95586] = 7, - ACTIONS(373), 1, + [112718] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3172), 1, - aux_sym_input_expression_token2, - ACTIONS(3175), 1, - aux_sym_do_while_statement_token1, - STATE(2831), 1, - sym_widget_phrase, - STATE(2159), 3, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2104), 1, + anon_sym_COLON, + STATE(2832), 1, + aux_sym_for_statement_repeat1, + STATE(2636), 2, sym_comment, sym_include, - aux_sym_on_statement_repeat2, - [95610] = 7, - ACTIONS(3), 1, + [112741] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3177), 1, - sym_identifier, - STATE(272), 1, - sym_qualified_name, - ACTIONS(3179), 2, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - STATE(2160), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3957), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2637), 2, sym_comment, sym_include, - [95634] = 5, + [112764] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(530), 1, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(71), 1, sym_identifier, - STATE(2161), 2, + ACTIONS(3959), 1, + sym__namedot, + STATE(2638), 3, sym_comment, sym_include, - ACTIONS(528), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95654] = 8, - ACTIONS(373), 1, + aux_sym_qualified_name_repeat1, + [112785] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3181), 1, + ACTIONS(3119), 1, anon_sym_COLON, - STATE(2227), 1, - sym_on_quit_phrase, - STATE(2986), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3544), 1, sym_on_stop_phrase, - STATE(2162), 2, + STATE(2639), 2, sym_comment, sym_include, - [95680] = 6, - ACTIONS(373), 1, + [112808] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3122), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2163), 2, + ACTIONS(3962), 1, + sym_identifier, + ACTIONS(3964), 1, + anon_sym_AMP, + ACTIONS(3966), 1, + sym__integer_literal, + STATE(2640), 2, sym_comment, sym_include, - ACTIONS(3183), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [95702] = 6, - ACTIONS(373), 1, + [112831] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3084), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2164), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(3968), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2641), 2, sym_comment, sym_include, - ACTIONS(3185), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [95724] = 8, - ACTIONS(373), 1, + [112854] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3187), 1, - anon_sym_COLON, - STATE(2187), 1, - sym_on_quit_phrase, - STATE(3103), 1, - sym_on_stop_phrase, - STATE(2165), 2, + ACTIONS(3970), 1, + anon_sym_RPAREN, + ACTIONS(3972), 1, + anon_sym_, + STATE(2579), 1, + aux_sym_accumulate_statement_repeat1, + STATE(2642), 2, sym_comment, sym_include, - [95750] = 7, - ACTIONS(3), 1, + [112877] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3189), 1, - anon_sym_DQUOTE, - STATE(2108), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2166), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3974), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2643), 2, sym_comment, sym_include, - [95774] = 7, - ACTIONS(3), 1, + [112900] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3191), 1, - anon_sym_SQUOTE, - STATE(2081), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2167), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3976), 1, + anon_sym_COLON, + STATE(2643), 1, + aux_sym_for_statement_repeat1, + STATE(2644), 2, sym_comment, sym_include, - [95798] = 7, - ACTIONS(3), 1, + [112923] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3193), 1, - anon_sym_SQUOTE, - STATE(2081), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2168), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3976), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2645), 2, sym_comment, sym_include, - [95822] = 8, - ACTIONS(373), 1, + [112946] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2673), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2042), 1, anon_sym_COLON, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - STATE(2235), 1, - sym_on_quit_phrase, - STATE(3000), 1, - sym_on_stop_phrase, - STATE(2169), 2, + STATE(2556), 1, + aux_sym_for_statement_repeat1, + STATE(2646), 2, sym_comment, sym_include, - [95848] = 5, - ACTIONS(373), 1, + [112969] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2170), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3978), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2647), 2, sym_comment, sym_include, - ACTIONS(3195), 4, - sym__terminator, + [112992] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2104), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [95868] = 6, - ACTIONS(373), 1, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2648), 2, + sym_comment, + sym_include, + [113015] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3197), 1, - aux_sym_procedure_parameter_definition_token1, - STATE(2171), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3396), 1, + anon_sym_COLON, + STATE(2645), 1, + aux_sym_for_statement_repeat1, + STATE(2649), 2, sym_comment, sym_include, - ACTIONS(3199), 3, - aux_sym_on_error_phrase_token4, - aux_sym_on_error_phrase_token5, - aux_sym_on_error_phrase_token6, - [95890] = 6, - ACTIONS(3), 1, + [113038] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3201), 1, - sym_identifier, - STATE(2172), 2, - sym_comment, - sym_include, - ACTIONS(3203), 3, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(3396), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [95912] = 5, - ACTIONS(3), 1, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2650), 2, + sym_comment, + sym_include, + [113061] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(406), 1, - sym_identifier, - STATE(2173), 2, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3980), 1, + anon_sym_COLON, + STATE(2647), 1, + aux_sym_for_statement_repeat1, + STATE(2651), 2, sym_comment, sym_include, - ACTIONS(404), 4, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_DQUOTE, - aux_sym_include_argument_token1, - [95932] = 7, - ACTIONS(3), 1, + [113084] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3205), 1, - sym_identifier, - STATE(267), 1, - sym_qualified_name, - ACTIONS(3207), 2, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - STATE(2174), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3980), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2652), 2, sym_comment, sym_include, - [95956] = 8, - ACTIONS(373), 1, + [113107] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3209), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3195), 1, anon_sym_COLON, - STATE(2525), 1, - sym_on_quit_phrase, - STATE(3064), 1, - sym_on_stop_phrase, - STATE(2175), 2, + STATE(2650), 1, + aux_sym_for_statement_repeat1, + STATE(2653), 2, sym_comment, sym_include, - [95982] = 7, - ACTIONS(3), 1, + [113130] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3211), 1, - anon_sym_DQUOTE, - STATE(2079), 1, - aux_sym_double_quoted_string_repeat1, - ACTIONS(2978), 2, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - STATE(2176), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3195), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2654), 2, sym_comment, sym_include, - [96006] = 7, - ACTIONS(3), 1, + [113153] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3213), 1, - anon_sym_SQUOTE, - STATE(2168), 1, - aux_sym_single_quoted_string_repeat1, - ACTIONS(3057), 2, - aux_sym_double_quoted_string_token2, - aux_sym_single_quoted_string_token1, - STATE(2177), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3404), 1, + anon_sym_COLON, + STATE(2652), 1, + aux_sym_for_statement_repeat1, + STATE(2655), 2, sym_comment, sym_include, - [96030] = 8, - ACTIONS(373), 1, + [113176] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3215), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3404), 1, anon_sym_COLON, - STATE(2245), 1, - sym_on_quit_phrase, - STATE(3099), 1, - sym_on_stop_phrase, - STATE(2178), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2656), 2, sym_comment, sym_include, - [96056] = 8, - ACTIONS(373), 1, + [113199] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2720), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3217), 1, - anon_sym_COLON, - STATE(2519), 1, - sym_on_quit_phrase, - STATE(3070), 1, - sym_on_stop_phrase, - STATE(2179), 2, + ACTIONS(3982), 1, + anon_sym_RPAREN, + ACTIONS(3984), 1, + anon_sym_COMMA, + STATE(2657), 3, sym_comment, sym_include, - [96082] = 7, - ACTIONS(373), 1, + aux_sym__function_call_arguments_repeat1, + [113220] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1952), 1, + ACTIONS(2723), 1, anon_sym_COLON, - STATE(2268), 1, + STATE(2654), 1, aux_sym_for_statement_repeat1, - STATE(2180), 2, + STATE(2658), 2, sym_comment, sym_include, - [96105] = 5, - ACTIONS(373), 1, + [113243] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2181), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2723), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2659), 2, sym_comment, sym_include, - ACTIONS(1318), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [96124] = 7, - ACTIONS(373), 1, + [113266] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1980), 1, + ACTIONS(3191), 1, anon_sym_COLON, - STATE(2186), 1, + STATE(2656), 1, aux_sym_for_statement_repeat1, - STATE(2182), 2, + STATE(2660), 2, sym_comment, sym_include, - [96147] = 7, - ACTIONS(373), 1, + [113289] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3219), 1, + ACTIONS(3191), 1, anon_sym_COLON, - STATE(2205), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2183), 2, + STATE(2661), 2, sym_comment, sym_include, - [96170] = 7, - ACTIONS(373), 1, + [113312] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3221), 1, - aux_sym__block_terminator_token1, - STATE(1277), 1, - sym__function_terminator, - STATE(1375), 1, - sym__block_terminator, - STATE(2184), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2162), 1, + anon_sym_COLON, + STATE(2659), 1, + aux_sym_for_statement_repeat1, + STATE(2662), 2, sym_comment, sym_include, - [96193] = 7, - ACTIONS(3), 1, + [113335] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3223), 1, - sym_identifier, - ACTIONS(3225), 1, - anon_sym_AMP, - ACTIONS(3227), 1, - sym__integer_literal, - STATE(2185), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2162), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2663), 2, sym_comment, sym_include, - [96216] = 7, - ACTIONS(373), 1, + [113358] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2016), 1, + ACTIONS(2721), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2661), 1, aux_sym_for_statement_repeat1, - STATE(2186), 2, + STATE(2664), 2, sym_comment, sym_include, - [96239] = 7, - ACTIONS(373), 1, + [113381] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3229), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2721), 1, anon_sym_COLON, - STATE(3093), 1, - sym_on_stop_phrase, - STATE(2187), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2665), 2, sym_comment, sym_include, - [96262] = 7, - ACTIONS(3), 1, + [113404] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3231), 1, - sym_identifier, - ACTIONS(3233), 1, - aux_sym_input_expression_token2, - STATE(812), 1, - sym_qualified_name, - STATE(2188), 2, + STATE(2666), 2, sym_comment, sym_include, - [96285] = 7, - ACTIONS(373), 1, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [113423] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2016), 1, + ACTIONS(2168), 1, anon_sym_COLON, - STATE(2374), 1, + STATE(2663), 1, aux_sym_for_statement_repeat1, - STATE(2189), 2, + STATE(2667), 2, sym_comment, sym_include, - [96308] = 7, - ACTIONS(3), 1, + [113446] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(862), 1, - anon_sym_LPAREN, - ACTIONS(3235), 1, - sym_identifier, - STATE(814), 1, - sym_parenthesized_expression, - STATE(2190), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2168), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2668), 2, sym_comment, sym_include, - [96331] = 7, - ACTIONS(373), 1, + [113469] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2870), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2191), 2, + ACTIONS(3987), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2669), 2, sym_comment, sym_include, - [96354] = 7, - ACTIONS(373), 1, + [113492] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2673), 1, - anon_sym_COLON, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - STATE(3000), 1, + ACTIONS(3989), 1, + anon_sym_COLON, + STATE(3398), 1, sym_on_stop_phrase, - STATE(2192), 2, + STATE(2670), 2, sym_comment, sym_include, - [96377] = 7, - ACTIONS(373), 1, + [113515] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2406), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3991), 1, anon_sym_COLON, - STATE(2400), 1, - aux_sym_for_statement_repeat1, - STATE(2193), 2, + STATE(3407), 1, + sym_on_stop_phrase, + STATE(2671), 2, sym_comment, sym_include, - [96400] = 7, - ACTIONS(373), 1, + [113538] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1952), 1, + ACTIONS(2160), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2665), 1, aux_sym_for_statement_repeat1, - STATE(2194), 2, + STATE(2672), 2, sym_comment, sym_include, - [96423] = 7, - ACTIONS(373), 1, + [113561] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2004), 1, + ACTIONS(2160), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2195), 2, + STATE(2673), 2, sym_comment, sym_include, - [96446] = 7, - ACTIONS(373), 1, + [113584] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2406), 1, + ACTIONS(2102), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2196), 2, + STATE(2674), 2, sym_comment, sym_include, - [96469] = 7, - ACTIONS(373), 1, + [113607] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1962), 1, + ACTIONS(2102), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2668), 1, aux_sym_for_statement_repeat1, - STATE(2197), 2, + STATE(2675), 2, sym_comment, sym_include, - [96492] = 7, - ACTIONS(373), 1, + [113630] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3237), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2198), 2, + ACTIONS(3993), 1, + sym__integer_literal, + STATE(301), 1, + sym__decimal_literal, + STATE(1952), 1, + sym_number_literal, + STATE(2676), 2, sym_comment, sym_include, - [96515] = 6, - ACTIONS(373), 1, + [113653] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3239), 1, - anon_sym_RPAREN, - ACTIONS(3241), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(2199), 3, + ACTIONS(2042), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2677), 2, sym_comment, sym_include, - aux_sym__function_call_arguments_repeat1, - [96536] = 7, - ACTIONS(373), 1, + [113676] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2042), 1, + ACTIONS(2144), 1, anon_sym_COLON, - STATE(2531), 1, + STATE(2735), 1, aux_sym_for_statement_repeat1, - STATE(2200), 2, + STATE(2678), 2, sym_comment, sym_include, - [96559] = 7, - ACTIONS(373), 1, + [113699] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2870), 1, + ACTIONS(2118), 1, anon_sym_COLON, - STATE(2229), 1, + STATE(2673), 1, aux_sym_for_statement_repeat1, - STATE(2201), 2, + STATE(2679), 2, sym_comment, sym_include, - [96582] = 7, - ACTIONS(373), 1, + [113722] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2004), 1, + ACTIONS(2118), 1, anon_sym_COLON, - STATE(2321), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2202), 2, + STATE(2680), 2, sym_comment, sym_include, - [96605] = 7, - ACTIONS(373), 1, + [113745] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3244), 1, + ACTIONS(3995), 1, anon_sym_COLON, - STATE(3068), 1, + STATE(3472), 1, sym_on_stop_phrase, - STATE(2203), 2, + STATE(2681), 2, sym_comment, sym_include, - [96628] = 7, - ACTIONS(373), 1, + [113768] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3246), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2058), 1, anon_sym_COLON, - STATE(3069), 1, - sym_on_stop_phrase, - STATE(2204), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2682), 2, sym_comment, sym_include, - [96651] = 7, - ACTIONS(373), 1, + [113791] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3997), 1, + aux_sym__block_terminator_token1, + STATE(1198), 1, + sym__function_terminator, + STATE(1301), 1, + sym__block_terminator, + STATE(2683), 2, + sym_comment, + sym_include, + [113814] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3997), 1, + aux_sym__block_terminator_token1, + STATE(1262), 1, + sym__function_terminator, + STATE(1301), 1, + sym__block_terminator, + STATE(2684), 2, + sym_comment, + sym_include, + [113837] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3999), 1, anon_sym_COMMA, - ACTIONS(3248), 1, + ACTIONS(4002), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2205), 2, + STATE(2685), 3, sym_comment, sym_include, - [96674] = 7, - ACTIONS(373), 1, + aux_sym_for_statement_repeat1, + [113858] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3250), 1, - anon_sym_RPAREN, - ACTIONS(3252), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(2549), 1, - aux_sym__function_call_arguments_repeat1, - STATE(2206), 2, + ACTIONS(2058), 1, + anon_sym_COLON, + STATE(2674), 1, + aux_sym_for_statement_repeat1, + STATE(2686), 2, sym_comment, sym_include, - [96697] = 7, + [113881] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3254), 1, + ACTIONS(4004), 1, + sym_identifier, + ACTIONS(4006), 1, + aux_sym_class_statement_token1, + STATE(3418), 1, + sym_qualified_name, + STATE(2687), 2, + sym_comment, + sym_include, + [113904] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2688), 2, + sym_comment, + sym_include, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [113923] = 7, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(4008), 1, + sym_identifier, + ACTIONS(4010), 1, anon_sym_RPAREN, - ACTIONS(3256), 1, - anon_sym_, - STATE(2504), 1, - aux_sym_accumulate_statement_repeat1, - STATE(2207), 2, + STATE(2914), 1, + aux_sym_query_fields_repeat1, + STATE(2689), 2, sym_comment, sym_include, - [96720] = 7, + [113946] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3258), 1, + ACTIONS(65), 1, sym_identifier, - ACTIONS(3260), 1, - aux_sym_input_expression_token2, - STATE(317), 1, - sym_qualified_name, - STATE(2208), 2, + ACTIONS(4012), 1, + sym__namedot, + STATE(2638), 1, + aux_sym_qualified_name_repeat1, + STATE(2690), 2, sym_comment, sym_include, - [96743] = 7, - ACTIONS(373), 1, + [113969] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1984), 1, + ACTIONS(2074), 1, anon_sym_COLON, - STATE(2418), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2209), 2, + STATE(2691), 2, sym_comment, sym_include, - [96766] = 7, - ACTIONS(373), 1, + [113992] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + STATE(2692), 2, + sym_comment, + sym_include, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114011] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2046), 1, + ACTIONS(2074), 1, anon_sym_COLON, - STATE(2195), 1, + STATE(2680), 1, aux_sym_for_statement_repeat1, - STATE(2210), 2, + STATE(2693), 2, sym_comment, sym_include, - [96789] = 7, - ACTIONS(373), 1, + [114034] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3262), 1, - sym__integer_literal, - STATE(640), 1, - sym__decimal_literal, - STATE(1731), 1, - sym_number_literal, - STATE(2211), 2, + ACTIONS(4014), 1, + sym_identifier, + ACTIONS(4016), 1, + aux_sym_input_expression_token2, + STATE(804), 1, + sym_qualified_name, + STATE(2694), 2, sym_comment, sym_include, - [96812] = 7, - ACTIONS(373), 1, + [114057] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3215), 1, - anon_sym_COLON, - STATE(3099), 1, - sym_on_stop_phrase, - STATE(2212), 2, + STATE(2695), 2, sym_comment, sym_include, - [96835] = 5, + ACTIONS(1330), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114076] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2213), 2, + ACTIONS(842), 1, + anon_sym_LPAREN, + ACTIONS(4018), 1, + sym_identifier, + STATE(931), 1, + sym_parenthesized_expression, + STATE(2696), 2, sym_comment, sym_include, - ACTIONS(3264), 3, - aux_sym_double_quoted_string_token2, - anon_sym_SQUOTE, - aux_sym_single_quoted_string_token1, - [96854] = 7, - ACTIONS(373), 1, + [114099] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3266), 1, + ACTIONS(4020), 1, anon_sym_COLON, - STATE(3101), 1, + STATE(3455), 1, sym_on_stop_phrase, - STATE(2214), 2, + STATE(2697), 2, sym_comment, sym_include, - [96877] = 7, - ACTIONS(373), 1, + [114122] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3221), 1, - aux_sym__block_terminator_token1, - STATE(1239), 1, - sym__function_terminator, - STATE(1375), 1, - sym__block_terminator, - STATE(2215), 2, + STATE(2698), 2, sym_comment, sym_include, - [96900] = 7, - ACTIONS(373), 1, + ACTIONS(1326), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114141] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3268), 1, + ACTIONS(4022), 1, anon_sym_COLON, - STATE(3137), 1, + STATE(3454), 1, sym_on_stop_phrase, - STATE(2216), 2, + STATE(2699), 2, sym_comment, sym_include, - [96923] = 6, - ACTIONS(373), 1, + [114164] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3270), 1, - aux_sym__block_terminator_token1, - STATE(1303), 2, - sym__block_terminator, - sym__procedure_terminator, - STATE(2217), 2, + STATE(2700), 2, sym_comment, sym_include, - [96944] = 7, + ACTIONS(1322), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114183] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3272), 1, + ACTIONS(4008), 1, sym_identifier, - ACTIONS(3274), 1, - anon_sym_AMP, - ACTIONS(3276), 1, - sym__integer_literal, - STATE(2218), 2, + ACTIONS(4024), 1, + anon_sym_RPAREN, + STATE(2689), 1, + aux_sym_query_fields_repeat1, + STATE(2701), 2, sym_comment, sym_include, - [96967] = 5, + [114206] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2219), 2, + ACTIONS(3972), 1, + anon_sym_, + ACTIONS(4026), 1, + anon_sym_RPAREN, + STATE(2642), 1, + aux_sym_accumulate_statement_repeat1, + STATE(2702), 2, sym_comment, sym_include, - ACTIONS(3278), 3, - anon_sym_DQUOTE, - aux_sym_double_quoted_string_token1, - aux_sym_double_quoted_string_token2, - [96986] = 7, - ACTIONS(373), 1, + [114229] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3280), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2220), 2, + STATE(2703), 2, sym_comment, sym_include, - [97009] = 7, - ACTIONS(373), 1, + ACTIONS(1318), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114248] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4028), 1, + anon_sym_COLON, + STATE(3441), 1, + sym_on_stop_phrase, + STATE(2704), 2, + sym_comment, + sym_include, + [114271] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2002), 1, + ACTIONS(2144), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2221), 2, + STATE(2705), 2, sym_comment, sym_include, - [97032] = 7, - ACTIONS(373), 1, + [114294] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3221), 1, - aux_sym__block_terminator_token1, - STATE(1375), 1, - sym__block_terminator, - STATE(1377), 1, - sym__function_terminator, - STATE(2222), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2706), 2, + sym_comment, + sym_include, + [114317] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2062), 1, + anon_sym_COLON, + STATE(2691), 1, + aux_sym_for_statement_repeat1, + STATE(2707), 2, sym_comment, sym_include, - [97055] = 7, - ACTIONS(373), 1, + [114340] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, + ACTIONS(67), 1, sym__namedot, - ACTIONS(3282), 1, - anon_sym_COLON, - STATE(275), 1, + ACTIONS(4030), 1, + sym__terminator, + STATE(2), 1, aux_sym_qualified_name_repeat1, - STATE(2223), 2, + STATE(2708), 2, sym_comment, sym_include, - [97078] = 7, - ACTIONS(373), 1, + [114363] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2042), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3555), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2224), 2, + STATE(3424), 1, + sym_on_stop_phrase, + STATE(2709), 2, sym_comment, sym_include, - [97101] = 7, - ACTIONS(373), 1, + [114386] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3284), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4032), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2225), 2, + STATE(3423), 1, + sym_on_stop_phrase, + STATE(2710), 2, sym_comment, sym_include, - [97124] = 7, - ACTIONS(373), 1, + [114409] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(3219), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2226), 2, + ACTIONS(3443), 1, + anon_sym_RPAREN, + STATE(2495), 1, + aux_sym_data_relation_repeat1, + STATE(2711), 2, sym_comment, sym_include, - [97147] = 7, - ACTIONS(373), 1, + [114432] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3286), 1, + ACTIONS(4034), 1, anon_sym_COLON, - STATE(2981), 1, + STATE(3775), 1, sym_on_stop_phrase, - STATE(2227), 2, + STATE(2712), 2, sym_comment, sym_include, - [97170] = 7, - ACTIONS(373), 1, + [114455] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, + ACTIONS(67), 1, sym__namedot, - ACTIONS(3288), 1, + ACTIONS(4036), 1, anon_sym_LPAREN, - STATE(275), 1, + STATE(2), 1, aux_sym_qualified_name_repeat1, - STATE(2228), 2, + STATE(2713), 2, sym_comment, sym_include, - [97193] = 7, - ACTIONS(373), 1, + [114478] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3290), 1, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4038), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2229), 2, - sym_comment, - sym_include, - [97216] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(2230), 2, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2714), 2, sym_comment, sym_include, - ACTIONS(3292), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [97235] = 7, - ACTIONS(373), 1, + [114501] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2046), 1, + ACTIONS(3089), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2231), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3409), 1, + sym_on_stop_phrase, + STATE(2715), 2, sym_comment, sym_include, - [97258] = 6, + [114524] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3294), 1, + ACTIONS(4040), 1, sym_identifier, - ACTIONS(3041), 2, - sym__terminator, - anon_sym_COLON, - STATE(2232), 2, + ACTIONS(4042), 1, + anon_sym_AMP, + ACTIONS(4044), 1, + sym__integer_literal, + STATE(2716), 2, sym_comment, sym_include, - [97279] = 7, - ACTIONS(373), 1, + [114547] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3296), 1, - anon_sym_COLON, - STATE(2985), 1, - sym_on_stop_phrase, - STATE(2233), 2, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(3443), 1, + anon_sym_RPAREN, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(2717), 2, sym_comment, sym_include, - [97302] = 6, - ACTIONS(373), 1, + [114570] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3298), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3301), 1, + ACTIONS(4046), 1, anon_sym_COLON, - STATE(2234), 3, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2718), 2, sym_comment, sym_include, + [114593] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4048), 1, + anon_sym_COLON, + STATE(2718), 1, aux_sym_for_statement_repeat1, - [97323] = 7, - ACTIONS(373), 1, + STATE(2719), 2, + sym_comment, + sym_include, + [114616] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3156), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4048), 1, anon_sym_COLON, - STATE(2984), 1, - sym_on_stop_phrase, - STATE(2235), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2720), 2, sym_comment, sym_include, - [97346] = 7, - ACTIONS(3), 1, + [114639] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3303), 1, - sym_identifier, - ACTIONS(3305), 1, - anon_sym_RPAREN, - STATE(2535), 1, - aux_sym_query_fields_repeat1, - STATE(2236), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4050), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2721), 2, sym_comment, sym_include, - [97369] = 7, - ACTIONS(373), 1, + [114662] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2006), 1, + ACTIONS(3449), 1, anon_sym_COLON, - STATE(2224), 1, + STATE(2720), 1, aux_sym_for_statement_repeat1, - STATE(2237), 2, + STATE(2722), 2, sym_comment, sym_include, - [97392] = 7, - ACTIONS(373), 1, + [114685] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2643), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3449), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(3119), 1, - sym_on_stop_phrase, - STATE(2238), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2723), 2, sym_comment, sym_include, - [97415] = 7, - ACTIONS(373), 1, + [114708] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3307), 1, + ACTIONS(4052), 1, anon_sym_COLON, - STATE(2225), 1, + STATE(2721), 1, aux_sym_for_statement_repeat1, - STATE(2239), 2, + STATE(2724), 2, sym_comment, sym_include, - [97438] = 5, - ACTIONS(373), 1, + [114731] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2240), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4052), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2725), 2, sym_comment, sym_include, - ACTIONS(3309), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [97457] = 7, - ACTIONS(373), 1, + [114754] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3307), 1, + ACTIONS(3229), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2723), 1, aux_sym_for_statement_repeat1, - STATE(2241), 2, + STATE(2726), 2, sym_comment, sym_include, - [97480] = 7, - ACTIONS(373), 1, + [114777] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3311), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3229), 1, anon_sym_COLON, - STATE(3080), 1, - sym_on_stop_phrase, - STATE(2242), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2727), 2, sym_comment, sym_include, - [97503] = 7, - ACTIONS(373), 1, + [114800] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3313), 1, + ACTIONS(3455), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2725), 1, aux_sym_for_statement_repeat1, - STATE(2243), 2, + STATE(2728), 2, sym_comment, sym_include, - [97526] = 7, - ACTIONS(3), 1, + [114823] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3315), 1, - sym_identifier, - ACTIONS(3317), 1, - anon_sym_AMP, - ACTIONS(3319), 1, - sym__integer_literal, - STATE(2244), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3455), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2729), 2, sym_comment, sym_include, - [97549] = 7, - ACTIONS(373), 1, + [114846] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3321), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2709), 1, anon_sym_COLON, - STATE(3072), 1, - sym_on_stop_phrase, - STATE(2245), 2, + STATE(2727), 1, + aux_sym_for_statement_repeat1, + STATE(2730), 2, sym_comment, sym_include, - [97572] = 7, - ACTIONS(373), 1, + [114869] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2843), 1, + ACTIONS(2709), 1, anon_sym_COLON, - STATE(2241), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2246), 2, + STATE(2731), 2, sym_comment, sym_include, - [97595] = 7, - ACTIONS(373), 1, + [114892] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3323), 1, + ACTIONS(3235), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2729), 1, aux_sym_for_statement_repeat1, - STATE(2247), 2, + STATE(2732), 2, sym_comment, sym_include, - [97618] = 7, - ACTIONS(373), 1, + [114915] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3325), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2248), 2, + STATE(2733), 2, sym_comment, sym_include, - [97641] = 7, - ACTIONS(373), 1, + ACTIONS(1416), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [114934] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1972), 1, + ACTIONS(3235), 1, anon_sym_COLON, - STATE(2434), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2249), 2, + STATE(2734), 2, sym_comment, sym_include, - [97664] = 7, - ACTIONS(373), 1, + [114957] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3327), 1, + ACTIONS(2729), 1, anon_sym_COLON, - STATE(2247), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2250), 2, + STATE(2735), 2, sym_comment, sym_include, - [97687] = 7, - ACTIONS(373), 1, + [114980] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3993), 1, + sym__integer_literal, + STATE(301), 1, + sym__decimal_literal, + STATE(2362), 1, + sym_number_literal, + STATE(2736), 2, + sym_comment, + sym_include, + [115003] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3327), 1, + ACTIONS(2122), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2731), 1, aux_sym_for_statement_repeat1, - STATE(2251), 2, + STATE(2737), 2, sym_comment, sym_include, - [97710] = 7, - ACTIONS(373), 1, + [115026] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + STATE(2738), 2, + sym_comment, + sym_include, + ACTIONS(1420), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [115045] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1962), 1, + ACTIONS(2122), 1, anon_sym_COLON, - STATE(2380), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2252), 2, + STATE(2739), 2, sym_comment, sym_include, - [97733] = 6, - ACTIONS(3), 1, + [115068] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3329), 1, - sym_identifier, - ACTIONS(3092), 2, - sym__terminator, - anon_sym_COLON, - STATE(2253), 2, + STATE(2740), 2, sym_comment, sym_include, - [97754] = 7, - ACTIONS(373), 1, + ACTIONS(1308), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [115087] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3331), 1, - anon_sym_COLON, - STATE(3111), 1, - sym_on_stop_phrase, - STATE(2254), 2, + ACTIONS(4054), 1, + sym_identifier, + ACTIONS(4056), 1, + anon_sym_RPAREN, + STATE(2711), 1, + sym_qualified_name, + STATE(2741), 2, sym_comment, sym_include, - [97777] = 7, - ACTIONS(373), 1, + [115110] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(3333), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2255), 2, + ACTIONS(3459), 1, + anon_sym_RPAREN, + STATE(2717), 1, + aux_sym_data_relation_repeat1, + STATE(2742), 2, sym_comment, sym_include, - [97800] = 7, - ACTIONS(373), 1, + [115133] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2843), 1, + ACTIONS(2725), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2734), 1, aux_sym_for_statement_repeat1, - STATE(2256), 2, + STATE(2743), 2, sym_comment, sym_include, - [97823] = 7, - ACTIONS(373), 1, + [115156] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2828), 1, + ACTIONS(2725), 1, anon_sym_COLON, - STATE(2191), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2257), 2, + STATE(2744), 2, sym_comment, sym_include, - [97846] = 7, - ACTIONS(373), 1, + [115179] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2916), 1, + ACTIONS(2729), 1, anon_sym_COLON, - STATE(2251), 1, + STATE(2848), 1, aux_sym_for_statement_repeat1, - STATE(2258), 2, + STATE(2745), 2, sym_comment, sym_include, - [97869] = 7, - ACTIONS(373), 1, + [115202] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3335), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2259), 2, + STATE(2746), 2, sym_comment, sym_include, - [97892] = 7, - ACTIONS(373), 1, + ACTIONS(1304), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [115221] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2916), 1, + ACTIONS(2124), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2739), 1, aux_sym_for_statement_repeat1, - STATE(2260), 2, + STATE(2747), 2, sym_comment, sym_include, - [97915] = 7, - ACTIONS(373), 1, + [115244] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3337), 1, - anon_sym_COLON, - STATE(2255), 1, - aux_sym_for_statement_repeat1, - STATE(2261), 2, + STATE(2748), 2, sym_comment, sym_include, - [97938] = 5, - ACTIONS(373), 1, + ACTIONS(1300), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [115263] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2262), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2124), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2749), 2, sym_comment, sym_include, - ACTIONS(3339), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [97957] = 7, - ACTIONS(373), 1, + [115286] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3337), 1, + ACTIONS(4058), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2263), 2, + STATE(2750), 2, sym_comment, sym_include, - [97980] = 7, - ACTIONS(373), 1, + [115309] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3290), 1, + ACTIONS(2126), 1, anon_sym_COLON, - STATE(2265), 1, + STATE(2744), 1, aux_sym_for_statement_repeat1, - STATE(2264), 2, + STATE(2751), 2, sym_comment, sym_include, - [98003] = 7, - ACTIONS(373), 1, + [115332] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3341), 1, + ACTIONS(2126), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2265), 2, + STATE(2752), 2, sym_comment, sym_include, - [98026] = 7, - ACTIONS(373), 1, + [115355] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(3343), 1, - anon_sym_COLON, - STATE(2243), 1, - aux_sym_for_statement_repeat1, - STATE(2266), 2, + ACTIONS(4060), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2753), 2, sym_comment, sym_include, - [98049] = 7, - ACTIONS(373), 1, + [115378] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2764), 1, - anon_sym_COLON, - STATE(2260), 1, - aux_sym_for_statement_repeat1, - STATE(2267), 2, + ACTIONS(4062), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2754), 2, sym_comment, sym_include, - [98072] = 7, - ACTIONS(373), 1, + [115401] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1972), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2268), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4064), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2755), 2, sym_comment, sym_include, - [98095] = 7, - ACTIONS(373), 1, + [115424] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2764), 1, + ACTIONS(2114), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2269), 2, + STATE(2756), 2, sym_comment, sym_include, - [98118] = 7, - ACTIONS(373), 1, + [115447] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1966), 1, + ACTIONS(2114), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2749), 1, aux_sym_for_statement_repeat1, - STATE(2270), 2, + STATE(2757), 2, sym_comment, sym_include, - [98141] = 7, - ACTIONS(3), 1, + [115470] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(115), 1, - anon_sym_LPAREN, - ACTIONS(3345), 1, - sym_identifier, - STATE(323), 1, - sym_parenthesized_expression, - STATE(2271), 2, + ACTIONS(3852), 1, + aux_sym__block_terminator_token1, + STATE(1342), 2, + sym__block_terminator, + sym__procedure_terminator, + STATE(2758), 2, sym_comment, sym_include, - [98164] = 7, - ACTIONS(373), 1, + [115491] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2918), 1, + ACTIONS(2128), 1, anon_sym_COLON, - STATE(2263), 1, + STATE(2752), 1, aux_sym_for_statement_repeat1, - STATE(2272), 2, + STATE(2759), 2, sym_comment, sym_include, - [98187] = 7, - ACTIONS(3), 1, + [115514] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3347), 1, - sym_identifier, - ACTIONS(3349), 1, - anon_sym_AMP, - ACTIONS(3351), 1, - sym__integer_literal, - STATE(2273), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2128), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2760), 2, sym_comment, sym_include, - [98210] = 7, - ACTIONS(373), 1, + [115537] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2918), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4066), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2274), 2, + STATE(3378), 1, + sym_on_stop_phrase, + STATE(2761), 2, sym_comment, sym_include, - [98233] = 7, - ACTIONS(3), 1, + [115560] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3258), 1, - sym_identifier, - ACTIONS(3260), 1, - aux_sym_input_expression_token2, - STATE(317), 1, - sym_qualified_name, - STATE(2275), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2762), 2, sym_comment, sym_include, - [98256] = 7, - ACTIONS(373), 1, + [115583] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2006), 1, + ACTIONS(2776), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2825), 1, aux_sym_for_statement_repeat1, - STATE(2276), 2, + STATE(2763), 2, sym_comment, sym_include, - [98279] = 7, - ACTIONS(373), 1, + [115606] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2687), 1, - aux_sym__block_terminator_token1, - STATE(1031), 1, - sym__case_terminator, - STATE(1247), 1, - sym__block_terminator, - STATE(2277), 2, + STATE(2764), 2, sym_comment, sym_include, - [98302] = 7, - ACTIONS(373), 1, + ACTIONS(4068), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [115625] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3353), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2278), 2, + STATE(2765), 2, sym_comment, sym_include, - [98325] = 5, - ACTIONS(373), 1, + ACTIONS(4070), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [115644] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2279), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2068), 1, + anon_sym_COLON, + STATE(2756), 1, + aux_sym_for_statement_repeat1, + STATE(2766), 2, sym_comment, sym_include, - ACTIONS(3355), 3, + [115667] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3997), 1, aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [98344] = 7, - ACTIONS(373), 1, + STATE(1130), 1, + sym__function_terminator, + STATE(1301), 1, + sym__block_terminator, + STATE(2767), 2, + sym_comment, + sym_include, + [115690] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3343), 1, + ACTIONS(2108), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2280), 2, + STATE(2768), 2, sym_comment, sym_include, - [98367] = 7, - ACTIONS(373), 1, + [115713] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3357), 1, - anon_sym_RPAREN, - ACTIONS(3359), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(2324), 1, - aux_sym_function_statement_repeat1, - STATE(2281), 2, + ACTIONS(2108), 1, + anon_sym_COLON, + STATE(2760), 1, + aux_sym_for_statement_repeat1, + STATE(2769), 2, sym_comment, sym_include, - [98390] = 7, - ACTIONS(373), 1, + [115736] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2392), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3741), 1, anon_sym_COLON, - STATE(2269), 1, - aux_sym_for_statement_repeat1, - STATE(2282), 2, + STATE(3700), 1, + sym_on_stop_phrase, + STATE(2770), 2, sym_comment, sym_include, - [98413] = 5, + [115759] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2283), 2, + ACTIONS(4072), 1, + sym_identifier, + ACTIONS(4074), 1, + anon_sym_RPAREN, + STATE(2742), 1, + sym_qualified_name, + STATE(2771), 2, sym_comment, sym_include, - ACTIONS(3361), 3, - sym_identifier, - sym__terminator, - anon_sym_NO_DASHERROR, - [98432] = 7, - ACTIONS(373), 1, + [115782] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2392), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4076), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2284), 2, + STATE(3437), 1, + sym_on_stop_phrase, + STATE(2772), 2, sym_comment, sym_include, - [98455] = 7, - ACTIONS(373), 1, + [115805] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2828), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4078), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2285), 2, + STATE(3431), 1, + sym_on_stop_phrase, + STATE(2773), 2, sym_comment, sym_include, - [98478] = 7, - ACTIONS(373), 1, + [115828] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4080), 1, + anon_sym_RPAREN, + ACTIONS(4082), 1, anon_sym_COMMA, - ACTIONS(2824), 1, - anon_sym_COLON, - STATE(2256), 1, - aux_sym_for_statement_repeat1, - STATE(2286), 2, + STATE(2774), 3, sym_comment, sym_include, - [98501] = 6, - ACTIONS(373), 1, + aux_sym_function_statement_repeat1, + [115849] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3270), 1, - aux_sym__block_terminator_token1, - STATE(1262), 2, - sym__block_terminator, - sym__procedure_terminator, - STATE(2287), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4085), 1, + anon_sym_COLON, + STATE(3448), 1, + sym_on_stop_phrase, + STATE(2775), 2, sym_comment, sym_include, - [98522] = 7, - ACTIONS(373), 1, + [115872] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2679), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2050), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(3049), 1, - sym_on_stop_phrase, - STATE(2288), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2776), 2, sym_comment, sym_include, - [98545] = 7, - ACTIONS(373), 1, + [115895] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3363), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2289), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4087), 1, + anon_sym_COLON, + STATE(3696), 1, + sym_on_stop_phrase, + STATE(2777), 2, sym_comment, sym_include, - [98568] = 7, - ACTIONS(373), 1, + [115918] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2752), 1, + ACTIONS(2050), 1, anon_sym_COLON, - STATE(2274), 1, + STATE(2768), 1, aux_sym_for_statement_repeat1, - STATE(2290), 2, + STATE(2778), 2, sym_comment, sym_include, - [98591] = 7, - ACTIONS(373), 1, + [115941] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2752), 1, + ACTIONS(4089), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2750), 1, aux_sym_for_statement_repeat1, - STATE(2291), 2, + STATE(2779), 2, sym_comment, sym_include, - [98614] = 5, - ACTIONS(373), 1, + [115964] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2292), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4089), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2780), 2, sym_comment, sym_include, - ACTIONS(3365), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [98633] = 7, - ACTIONS(373), 1, + [115987] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2824), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3477), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2293), 2, + STATE(3469), 1, + sym_on_stop_phrase, + STATE(2781), 2, sym_comment, sym_include, - [98656] = 7, - ACTIONS(373), 1, + [116010] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2002), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4091), 1, anon_sym_COLON, - STATE(2354), 1, - aux_sym_for_statement_repeat1, - STATE(2294), 2, + STATE(3471), 1, + sym_on_stop_phrase, + STATE(2782), 2, sym_comment, sym_include, - [98679] = 7, - ACTIONS(373), 1, + [116033] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2659), 1, - aux_sym__block_terminator_token1, - STATE(1229), 1, - sym__block_terminator, - STATE(1268), 1, - sym__case_terminator, - STATE(2295), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4093), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2783), 2, sym_comment, sym_include, - [98702] = 6, - ACTIONS(3), 1, + [116056] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3367), 1, - anon_sym_RPAREN, - ACTIONS(3369), 1, - anon_sym_, - STATE(2296), 3, + STATE(2784), 2, sym_comment, sym_include, - aux_sym_accumulate_statement_repeat1, - [98723] = 7, - ACTIONS(373), 1, + ACTIONS(4095), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [116075] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2876), 1, - anon_sym_COLON, - STATE(2280), 1, - aux_sym_for_statement_repeat1, - STATE(2297), 2, + STATE(2785), 2, sym_comment, sym_include, - [98746] = 7, - ACTIONS(373), 1, + ACTIONS(4097), 3, + anon_sym_COMMA, + anon_sym_COLON, + aux_sym_on_error_phrase_token1, + [116094] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1984), 1, + ACTIONS(3169), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2298), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3485), 1, + sym_on_stop_phrase, + STATE(2786), 2, sym_comment, sym_include, - [98769] = 7, - ACTIONS(373), 1, + [116117] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2876), 1, + ACTIONS(4099), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2869), 1, aux_sym_for_statement_repeat1, - STATE(2299), 2, + STATE(2787), 2, sym_comment, sym_include, - [98792] = 7, - ACTIONS(3), 1, + [116140] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3372), 1, - sym_identifier, - ACTIONS(3374), 1, - aux_sym_input_expression_token2, - STATE(772), 1, - sym_qualified_name, - STATE(2300), 2, + ACTIONS(3822), 1, + anon_sym_COMMA, + ACTIONS(4101), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2788), 2, sym_comment, sym_include, - [98815] = 7, - ACTIONS(373), 1, + [116163] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1948), 1, + ACTIONS(2776), 1, anon_sym_COLON, - STATE(2523), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2301), 2, + STATE(2789), 2, sym_comment, sym_include, - [98838] = 7, + [116186] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(810), 1, - anon_sym_LPAREN, - ACTIONS(3376), 1, + ACTIONS(4103), 1, sym_identifier, - STATE(777), 1, - sym_parenthesized_expression, - STATE(2302), 2, + ACTIONS(4105), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2790), 2, sym_comment, sym_include, - [98861] = 7, - ACTIONS(373), 1, + [116207] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3378), 1, - anon_sym_COLON, - STATE(2974), 1, - sym_on_stop_phrase, - STATE(2303), 2, + ACTIONS(4107), 1, + sym_identifier, + ACTIONS(4109), 1, + anon_sym_AMP, + ACTIONS(4111), 1, + sym__integer_literal, + STATE(2791), 2, sym_comment, sym_include, - [98884] = 7, - ACTIONS(373), 1, + [116230] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3380), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4113), 1, anon_sym_COLON, - STATE(3057), 1, - sym_on_stop_phrase, - STATE(2304), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2792), 2, sym_comment, sym_include, - [98907] = 7, - ACTIONS(373), 1, + [116253] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2377), 1, + ACTIONS(4115), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2792), 1, aux_sym_for_statement_repeat1, - STATE(2305), 2, + STATE(2793), 2, sym_comment, sym_include, - [98930] = 7, - ACTIONS(373), 1, + [116276] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2377), 1, + ACTIONS(4115), 1, anon_sym_COLON, - STATE(2516), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2306), 2, + STATE(2794), 2, sym_comment, sym_include, - [98953] = 7, - ACTIONS(373), 1, + [116299] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3382), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4117), 1, anon_sym_COLON, - STATE(3066), 1, - sym_on_stop_phrase, - STATE(2307), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2795), 2, sym_comment, sym_include, - [98976] = 7, - ACTIONS(373), 1, + [116322] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2022), 1, + ACTIONS(3453), 1, anon_sym_COLON, - STATE(2284), 1, + STATE(2794), 1, aux_sym_for_statement_repeat1, - STATE(2308), 2, + STATE(2796), 2, sym_comment, sym_include, - [98999] = 6, - ACTIONS(373), 1, + [116345] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3384), 1, - aux_sym__block_terminator_token1, - STATE(1070), 2, - sym__block_terminator, - sym__procedure_terminator, - STATE(2309), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3453), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2797), 2, sym_comment, sym_include, - [99020] = 7, - ACTIONS(373), 1, + [116368] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2022), 1, + ACTIONS(4119), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2795), 1, aux_sym_for_statement_repeat1, - STATE(2310), 2, + STATE(2798), 2, sym_comment, sym_include, - [99043] = 7, - ACTIONS(373), 1, + [116391] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3386), 1, - aux_sym_on_error_phrase_token2, - ACTIONS(3388), 1, - aux_sym_on_stop_phrase_token1, - ACTIONS(3390), 1, - aux_sym_on_quit_phrase_token1, - STATE(2311), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4119), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2799), 2, sym_comment, sym_include, - [99066] = 7, - ACTIONS(3), 1, + [116414] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3303), 1, - sym_identifier, - ACTIONS(3392), 1, - anon_sym_RPAREN, - STATE(2236), 1, - aux_sym_query_fields_repeat1, - STATE(2312), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3247), 1, + anon_sym_COLON, + STATE(2797), 1, + aux_sym_for_statement_repeat1, + STATE(2800), 2, sym_comment, sym_include, - [99089] = 5, - ACTIONS(373), 1, + [116437] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2313), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3247), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2801), 2, sym_comment, sym_include, - ACTIONS(3394), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [99108] = 5, - ACTIONS(373), 1, + [116460] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2314), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4121), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2802), 2, sym_comment, sym_include, - ACTIONS(3396), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [99127] = 7, - ACTIONS(373), 1, + [116483] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2365), 1, + ACTIONS(3445), 1, anon_sym_COLON, - STATE(2293), 1, + STATE(2799), 1, aux_sym_for_statement_repeat1, - STATE(2315), 2, - sym_comment, - sym_include, - [99150] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - STATE(2316), 2, + STATE(2803), 2, sym_comment, sym_include, - ACTIONS(3398), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [99169] = 7, - ACTIONS(373), 1, + [116506] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2402), 1, + ACTIONS(3445), 1, anon_sym_COLON, - STATE(2291), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2317), 2, + STATE(2804), 2, sym_comment, sym_include, - [99192] = 6, - ACTIONS(3), 1, + [116529] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3400), 1, - sym_identifier, - ACTIONS(3402), 2, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2760), 1, anon_sym_COLON, - STATE(2318), 2, + STATE(2801), 1, + aux_sym_for_statement_repeat1, + STATE(2805), 2, sym_comment, sym_include, - [99213] = 7, - ACTIONS(373), 1, + [116552] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3080), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2760), 1, anon_sym_COLON, - STATE(3067), 1, - sym_on_stop_phrase, - STATE(2319), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2806), 2, sym_comment, sym_include, - [99236] = 7, - ACTIONS(373), 1, + [116575] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2402), 1, + ACTIONS(3254), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2804), 1, aux_sym_for_statement_repeat1, - STATE(2320), 2, + STATE(2807), 2, sym_comment, sym_include, - [99259] = 7, - ACTIONS(373), 1, + [116598] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2398), 1, + ACTIONS(3254), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2321), 2, + STATE(2808), 2, sym_comment, sym_include, - [99282] = 5, - ACTIONS(373), 1, + [116621] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2322), 2, + STATE(2809), 2, sym_comment, sym_include, - ACTIONS(1430), 3, + ACTIONS(1296), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [99301] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3128), 1, - anon_sym_COLON, - STATE(3135), 1, - sym_on_stop_phrase, - STATE(2323), 2, - sym_comment, - sym_include, - [99324] = 7, - ACTIONS(373), 1, + [116640] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3359), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(3404), 1, + ACTIONS(4101), 1, anon_sym_RPAREN, - STATE(2345), 1, + STATE(2908), 1, aux_sym_function_statement_repeat1, - STATE(2324), 2, + STATE(2810), 2, sym_comment, sym_include, - [99347] = 7, - ACTIONS(373), 1, + [116663] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1966), 1, - anon_sym_COLON, - STATE(2510), 1, - aux_sym_for_statement_repeat1, - STATE(2325), 2, + STATE(2811), 2, sym_comment, sym_include, - [99370] = 5, - ACTIONS(373), 1, + ACTIONS(1436), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [116682] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2326), 2, + STATE(2812), 2, sym_comment, sym_include, - ACTIONS(3406), 3, + ACTIONS(4123), 3, + sym_identifier, + aux_sym_input_expression_token2, + aux_sym_do_while_statement_token1, + [116701] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, + ACTIONS(2134), 1, anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [99389] = 7, - ACTIONS(3), 1, + STATE(2806), 1, + aux_sym_for_statement_repeat1, + STATE(2813), 2, + sym_comment, + sym_include, + [116724] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3408), 1, - sym_identifier, - ACTIONS(3410), 1, - aux_sym_class_statement_token1, - STATE(3118), 1, - sym_qualified_name, - STATE(2327), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2134), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2814), 2, sym_comment, sym_include, - [99412] = 5, - ACTIONS(373), 1, + [116747] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2328), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4125), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2815), 2, sym_comment, sym_include, - ACTIONS(3412), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [99431] = 7, - ACTIONS(373), 1, + [116770] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2365), 1, + ACTIONS(2764), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2808), 1, aux_sym_for_statement_repeat1, - STATE(2329), 2, + STATE(2816), 2, sym_comment, sym_include, - [99454] = 7, - ACTIONS(373), 1, + [116793] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2018), 1, + ACTIONS(2764), 1, anon_sym_COLON, - STATE(2196), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2330), 2, + STATE(2817), 2, sym_comment, sym_include, - [99477] = 7, - ACTIONS(373), 1, + [116816] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3414), 1, - aux_sym__block_terminator_token1, - STATE(1039), 1, - sym__function_terminator, - STATE(1182), 1, - sym__block_terminator, - STATE(2331), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1699), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2818), 2, sym_comment, sym_include, - [99500] = 7, - ACTIONS(373), 1, + [116839] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1701), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2819), 2, + sym_comment, + sym_include, + [116862] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2790), 1, + ACTIONS(2136), 1, anon_sym_COLON, - STATE(2299), 1, + STATE(2814), 1, aux_sym_for_statement_repeat1, - STATE(2332), 2, + STATE(2820), 2, sym_comment, sym_include, - [99523] = 7, - ACTIONS(373), 1, + [116885] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2038), 1, + ACTIONS(2136), 1, anon_sym_COLON, - STATE(2542), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2333), 2, + STATE(2821), 2, sym_comment, sym_include, - [99546] = 5, - ACTIONS(373), 1, + [116908] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2334), 2, + STATE(2822), 2, sym_comment, sym_include, - ACTIONS(1400), 3, + ACTIONS(1424), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [99565] = 5, - ACTIONS(373), 1, + [116927] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2335), 2, + STATE(2823), 2, sym_comment, sym_include, - ACTIONS(1396), 3, + ACTIONS(1428), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [99584] = 7, - ACTIONS(373), 1, + [116946] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2008), 1, - anon_sym_COLON, - STATE(2310), 1, - aux_sym_for_statement_repeat1, - STATE(2336), 2, + ACTIONS(4127), 1, + sym_identifier, + ACTIONS(4129), 1, + aux_sym_input_expression_token2, + STATE(914), 1, + sym_qualified_name, + STATE(2824), 2, sym_comment, sym_include, - [99607] = 7, - ACTIONS(373), 1, + [116969] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2398), 1, + ACTIONS(3299), 1, anon_sym_COLON, - STATE(2388), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2337), 2, + STATE(2825), 2, sym_comment, sym_include, - [99630] = 5, - ACTIONS(373), 1, + [116992] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2338), 2, + ACTIONS(926), 1, + anon_sym_LPAREN, + ACTIONS(4131), 1, + sym_identifier, + STATE(645), 1, + sym_parenthesized_expression, + STATE(2826), 2, sym_comment, sym_include, - ACTIONS(1390), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99649] = 7, - ACTIONS(373), 1, + [117015] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3295), 1, + anon_sym_COLON, + STATE(2569), 1, + aux_sym_for_statement_repeat1, + STATE(2827), 2, + sym_comment, + sym_include, + [117038] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2018), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2339), 2, + ACTIONS(4133), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2828), 2, sym_comment, sym_include, - [99672] = 5, - ACTIONS(373), 1, + [117061] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2340), 2, + ACTIONS(3822), 1, + anon_sym_COMMA, + ACTIONS(3987), 1, + anon_sym_RPAREN, + STATE(2753), 1, + aux_sym_function_statement_repeat1, + STATE(2829), 2, sym_comment, sym_include, - ACTIONS(1378), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99691] = 7, - ACTIONS(373), 1, + [117084] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3416), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2138), 1, anon_sym_COLON, - STATE(2973), 1, - sym_on_stop_phrase, - STATE(2341), 2, + STATE(2817), 1, + aux_sym_for_statement_repeat1, + STATE(2830), 2, sym_comment, sym_include, - [99714] = 7, - ACTIONS(373), 1, + [117107] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2008), 1, + ACTIONS(2138), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2342), 2, + STATE(2831), 2, sym_comment, sym_include, - [99737] = 7, - ACTIONS(373), 1, + [117130] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2681), 1, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2120), 1, anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(3204), 1, - sym_on_stop_phrase, - STATE(2343), 2, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2832), 2, sym_comment, sym_include, - [99760] = 7, - ACTIONS(373), 1, + [117153] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3359), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3418), 1, - anon_sym_RPAREN, - STATE(2345), 1, - aux_sym_function_statement_repeat1, - STATE(2344), 2, + ACTIONS(2110), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2833), 2, sym_comment, sym_include, - [99783] = 6, - ACTIONS(373), 1, + [117176] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3420), 1, - anon_sym_RPAREN, - ACTIONS(3422), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - STATE(2345), 3, + ACTIONS(2110), 1, + anon_sym_COLON, + STATE(2821), 1, + aux_sym_for_statement_repeat1, + STATE(2834), 2, sym_comment, sym_include, - aux_sym_function_statement_repeat1, - [99804] = 5, - ACTIONS(373), 1, + [117199] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2346), 2, + ACTIONS(3822), 1, + anon_sym_COMMA, + ACTIONS(4135), 1, + anon_sym_RPAREN, + STATE(2828), 1, + aux_sym_function_statement_repeat1, + STATE(2835), 2, sym_comment, sym_include, - ACTIONS(1374), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99823] = 5, - ACTIONS(373), 1, + [117222] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2347), 2, + STATE(2836), 2, sym_comment, sym_include, - ACTIONS(1370), 3, + ACTIONS(1432), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [99842] = 5, - ACTIONS(373), 1, + [117241] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2348), 2, + STATE(2837), 2, sym_comment, sym_include, - ACTIONS(1366), 3, + ACTIONS(1436), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [99861] = 5, - ACTIONS(373), 1, + [117260] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2349), 2, + ACTIONS(3822), 1, + anon_sym_COMMA, + ACTIONS(4137), 1, + anon_sym_RPAREN, + STATE(2518), 1, + aux_sym_function_statement_repeat1, + STATE(2838), 2, sym_comment, sym_include, - ACTIONS(1362), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99880] = 5, - ACTIONS(373), 1, + [117283] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2350), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3299), 1, + anon_sym_COLON, + STATE(2885), 1, + aux_sym_for_statement_repeat1, + STATE(2839), 2, sym_comment, sym_include, - ACTIONS(1358), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99899] = 7, - ACTIONS(373), 1, + [117306] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3388), 1, - aux_sym_on_stop_phrase_token1, - ACTIONS(3425), 1, - aux_sym_on_error_phrase_token2, - ACTIONS(3427), 1, - aux_sym_on_quit_phrase_token1, - STATE(2351), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2140), 1, + anon_sym_COLON, + STATE(2831), 1, + aux_sym_for_statement_repeat1, + STATE(2840), 2, sym_comment, sym_include, - [99922] = 6, - ACTIONS(373), 1, + [117329] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3384), 1, - aux_sym__block_terminator_token1, - STATE(1041), 2, - sym__block_terminator, - sym__procedure_terminator, - STATE(2352), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(2140), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2841), 2, sym_comment, sym_include, - [99943] = 5, - ACTIONS(373), 1, + [117352] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2353), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4139), 1, + anon_sym_COLON, + STATE(3553), 1, + sym_on_stop_phrase, + STATE(2842), 2, sym_comment, sym_include, - ACTIONS(1354), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [99962] = 7, - ACTIONS(373), 1, + [117375] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2014), 1, + ACTIONS(2044), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2354), 2, + STATE(2843), 2, sym_comment, sym_include, - [99985] = 5, - ACTIONS(373), 1, + [117398] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2355), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4141), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2844), 2, sym_comment, sym_include, - ACTIONS(1350), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100004] = 7, - ACTIONS(373), 1, + [117421] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2014), 1, + ACTIONS(2044), 1, anon_sym_COLON, - STATE(2409), 1, + STATE(2833), 1, aux_sym_for_statement_repeat1, - STATE(2356), 2, + STATE(2845), 2, sym_comment, sym_include, - [100027] = 5, - ACTIONS(373), 1, + [117444] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2357), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1698), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2846), 2, sym_comment, sym_include, - ACTIONS(1346), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100046] = 5, - ACTIONS(373), 1, + [117467] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2358), 2, + ACTIONS(3972), 1, + anon_sym_, + ACTIONS(4143), 1, + anon_sym_RPAREN, + STATE(2579), 1, + aux_sym_accumulate_statement_repeat1, + STATE(2847), 2, sym_comment, sym_include, - ACTIONS(1342), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100065] = 5, - ACTIONS(373), 1, + [117490] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2359), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(3295), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2848), 2, sym_comment, sym_include, - ACTIONS(1338), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100084] = 5, - ACTIONS(373), 1, + [117513] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2360), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1691), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2849), 2, sym_comment, sym_include, - ACTIONS(1334), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100103] = 5, - ACTIONS(373), 1, + [117536] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2361), 2, + ACTIONS(3183), 1, + anon_sym_COMMA, + ACTIONS(4145), 1, + aux_sym_data_relation_token2, + STATE(2311), 1, + aux_sym_data_relation_repeat1, + STATE(2850), 2, sym_comment, sym_include, - ACTIONS(1330), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100122] = 7, - ACTIONS(373), 1, + [117559] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2024), 1, + ACTIONS(2112), 1, anon_sym_COLON, - STATE(2320), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2362), 2, + STATE(2851), 2, sym_comment, sym_include, - [100145] = 7, - ACTIONS(373), 1, + [117582] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2024), 1, + ACTIONS(2112), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2841), 1, aux_sym_for_statement_repeat1, - STATE(2363), 2, + STATE(2852), 2, sym_comment, sym_include, - [100168] = 5, - ACTIONS(373), 1, + [117605] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2364), 2, + ACTIONS(4147), 1, + sym_identifier, + ACTIONS(4149), 1, + aux_sym_buffer_definition_token3, + STATE(3514), 1, + sym_qualified_name, + STATE(2853), 2, sym_comment, sym_include, - ACTIONS(1326), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100187] = 5, - ACTIONS(373), 1, + [117628] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2365), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4151), 1, + anon_sym_COLON, + STATE(3580), 1, + sym_on_stop_phrase, + STATE(2854), 2, sym_comment, sym_include, - ACTIONS(1322), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100206] = 5, - ACTIONS(373), 1, + [117651] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2366), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4153), 1, + anon_sym_COLON, + STATE(3581), 1, + sym_on_stop_phrase, + STATE(2855), 2, sym_comment, sym_include, - ACTIONS(1322), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100225] = 5, - ACTIONS(373), 1, + [117674] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2367), 2, + ACTIONS(3972), 1, + anon_sym_, + ACTIONS(4155), 1, + anon_sym_RPAREN, + STATE(2847), 1, + aux_sym_accumulate_statement_repeat1, + STATE(2856), 2, sym_comment, sym_include, - ACTIONS(1322), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100244] = 5, - ACTIONS(373), 1, + [117697] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2368), 2, + STATE(2857), 2, sym_comment, sym_include, - ACTIONS(1322), 3, + ACTIONS(1510), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100263] = 7, - ACTIONS(373), 1, + [117716] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1980), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(4157), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2369), 2, + STATE(3596), 1, + sym_on_stop_phrase, + STATE(2858), 2, sym_comment, sym_include, - [100286] = 7, - ACTIONS(373), 1, + [117739] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3429), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2370), 2, + ACTIONS(3874), 1, + aux_sym_on_stop_phrase_token1, + ACTIONS(4159), 1, + aux_sym_on_error_phrase_token2, + ACTIONS(4161), 1, + aux_sym_on_quit_phrase_token1, + STATE(2859), 2, sym_comment, sym_include, - [100309] = 7, - ACTIONS(373), 1, + [117762] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1990), 1, + ACTIONS(2040), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2371), 2, + STATE(2860), 2, sym_comment, sym_include, - [100332] = 5, - ACTIONS(373), 1, + [117785] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2372), 2, + STATE(2861), 2, sym_comment, sym_include, - ACTIONS(1300), 3, + ACTIONS(1506), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100351] = 7, - ACTIONS(373), 1, + [117804] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1976), 1, + ACTIONS(2146), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2373), 2, + STATE(2862), 2, sym_comment, sym_include, - [100374] = 7, - ACTIONS(373), 1, + [117827] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2010), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2374), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4163), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2863), 2, sym_comment, sym_include, - [100397] = 7, - ACTIONS(373), 1, + [117850] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1982), 1, + ACTIONS(2146), 1, anon_sym_COLON, - STATE(2489), 1, + STATE(2789), 1, aux_sym_for_statement_repeat1, - STATE(2375), 2, + STATE(2864), 2, sym_comment, sym_include, - [100420] = 5, - ACTIONS(373), 1, + [117873] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2376), 2, + STATE(2865), 2, sym_comment, sym_include, - ACTIONS(1296), 3, + ACTIONS(1502), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100439] = 7, - ACTIONS(373), 1, + [117892] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3894), 1, anon_sym_COMMA, - ACTIONS(1988), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2377), 2, + ACTIONS(4165), 1, + anon_sym_RPAREN, + STATE(2539), 1, + aux_sym__function_call_arguments_repeat1, + STATE(2866), 2, sym_comment, sym_include, - [100462] = 5, - ACTIONS(373), 1, + [117915] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2378), 2, + ACTIONS(3993), 1, + sym__integer_literal, + STATE(301), 1, + sym__decimal_literal, + STATE(2443), 1, + sym_number_literal, + STATE(2867), 2, sym_comment, sym_include, - ACTIONS(1292), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100481] = 7, - ACTIONS(373), 1, + [117938] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1976), 1, + ACTIONS(2040), 1, anon_sym_COLON, - STATE(2342), 1, + STATE(2851), 1, aux_sym_for_statement_repeat1, - STATE(2379), 2, + STATE(2868), 2, sym_comment, sym_include, - [100504] = 7, - ACTIONS(373), 1, + [117961] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(1982), 1, + ACTIONS(4167), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2380), 2, + STATE(2869), 2, sym_comment, sym_include, - [100527] = 5, - ACTIONS(373), 1, + [117984] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2381), 2, + ACTIONS(4169), 1, + sym_identifier, + ACTIONS(4171), 1, + aux_sym_buffer_definition_token3, + STATE(3413), 1, + sym_qualified_name, + STATE(2870), 2, sym_comment, sym_include, - ACTIONS(1292), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100546] = 7, - ACTIONS(373), 1, + [118007] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3359), 1, - anon_sym_COMMA, - ACTIONS(3431), 1, - anon_sym_RPAREN, - STATE(2344), 1, - aux_sym_function_statement_repeat1, - STATE(2382), 2, + STATE(2871), 2, sym_comment, sym_include, - [100569] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4173), 3, anon_sym_COMMA, - ACTIONS(3433), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2383), 2, - sym_comment, - sym_include, - [100592] = 7, - ACTIONS(373), 1, + aux_sym_on_error_phrase_token1, + [118026] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2790), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2384), 2, + STATE(2872), 2, sym_comment, sym_include, - [100615] = 7, - ACTIONS(373), 1, + ACTIONS(1498), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118045] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3435), 1, - anon_sym_COLON, - STATE(2383), 1, - aux_sym_for_statement_repeat1, - STATE(2385), 2, + STATE(2873), 2, sym_comment, sym_include, - [100638] = 7, - ACTIONS(373), 1, + ACTIONS(1492), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118064] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3435), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2386), 2, + STATE(2874), 2, sym_comment, sym_include, - [100661] = 5, - ACTIONS(373), 1, + ACTIONS(1488), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118083] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2387), 2, + STATE(2875), 2, sym_comment, sym_include, - ACTIONS(1292), 3, + ACTIONS(1484), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100680] = 7, - ACTIONS(373), 1, + [118102] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2802), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2388), 2, + ACTIONS(3866), 1, + sym_identifier, + ACTIONS(3868), 1, + aux_sym_input_expression_token2, + STATE(339), 1, + sym_qualified_name, + STATE(2876), 2, sym_comment, sym_include, - [100703] = 5, - ACTIONS(373), 1, + [118125] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2389), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + ACTIONS(3595), 1, + anon_sym_COLON, + STATE(3639), 1, + sym_on_stop_phrase, + STATE(2877), 2, sym_comment, sym_include, - ACTIONS(1292), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [100722] = 7, - ACTIONS(373), 1, + [118148] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, + ACTIONS(3307), 1, aux_sym_on_error_phrase_token1, - ACTIONS(3437), 1, + ACTIONS(4175), 1, anon_sym_COLON, - STATE(3096), 1, + STATE(3642), 1, sym_on_stop_phrase, - STATE(2390), 2, + STATE(2878), 2, sym_comment, sym_include, - [100745] = 7, - ACTIONS(373), 1, + [118171] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2012), 1, - anon_sym_COLON, - STATE(2363), 1, - aux_sym_for_statement_repeat1, - STATE(2391), 2, + STATE(2879), 2, sym_comment, sym_include, - [100768] = 7, - ACTIONS(373), 1, + ACTIONS(4177), 3, + aux_sym_double_quoted_string_token2, + anon_sym_SQUOTE, + aux_sym_single_quoted_string_token1, + [118190] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2012), 1, + ACTIONS(2120), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2705), 1, aux_sym_for_statement_repeat1, - STATE(2392), 2, + STATE(2880), 2, sym_comment, sym_include, - [100791] = 7, - ACTIONS(373), 1, + [118213] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2010), 1, - anon_sym_COLON, - STATE(2481), 1, - aux_sym_for_statement_repeat1, - STATE(2393), 2, + STATE(2881), 2, sym_comment, sym_include, - [100814] = 7, - ACTIONS(373), 1, + ACTIONS(4179), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118232] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + STATE(2882), 2, + sym_comment, + sym_include, + ACTIONS(4181), 3, + anon_sym_DQUOTE, + aux_sym_double_quoted_string_token1, + aux_sym_double_quoted_string_token2, + [118251] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4183), 1, + anon_sym_LPAREN, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2883), 2, + sym_comment, + sym_include, + [118274] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(2802), 1, + ACTIONS(3390), 1, anon_sym_COLON, - STATE(2465), 1, + STATE(2780), 1, aux_sym_for_statement_repeat1, - STATE(2394), 2, + STATE(2884), 2, sym_comment, sym_include, - [100837] = 7, - ACTIONS(373), 1, + [118297] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(1278), 1, anon_sym_COMMA, - ACTIONS(3439), 1, + ACTIONS(3390), 1, anon_sym_COLON, - STATE(2234), 1, + STATE(2685), 1, aux_sym_for_statement_repeat1, - STATE(2395), 2, + STATE(2885), 2, sym_comment, sym_include, - [100860] = 7, - ACTIONS(373), 1, + [118320] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3441), 1, + ACTIONS(3129), 1, anon_sym_COLON, - STATE(2969), 1, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3680), 1, sym_on_stop_phrase, - STATE(2396), 2, + STATE(2886), 2, + sym_comment, + sym_include, + [118343] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + STATE(2887), 2, sym_comment, sym_include, - [100883] = 5, - ACTIONS(373), 1, + ACTIONS(1480), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118362] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2397), 2, + STATE(2888), 2, sym_comment, sym_include, - ACTIONS(1292), 3, + ACTIONS(1476), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100902] = 7, - ACTIONS(373), 1, + [118381] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1960), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2398), 2, + ACTIONS(4185), 1, + sym_identifier, + ACTIONS(4187), 1, + anon_sym_AMP, + ACTIONS(4189), 1, + sym__integer_literal, + STATE(2889), 2, sym_comment, sym_include, - [100925] = 5, - ACTIONS(373), 1, + [118404] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2399), 2, + STATE(2890), 2, sym_comment, sym_include, - ACTIONS(1292), 3, + ACTIONS(1472), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100944] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2724), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2400), 2, - sym_comment, - sym_include, - [100967] = 5, - ACTIONS(373), 1, + [118423] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2401), 2, + STATE(2891), 2, sym_comment, sym_include, - ACTIONS(1288), 3, + ACTIONS(1468), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [100986] = 7, - ACTIONS(373), 1, + [118442] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1964), 1, - anon_sym_COLON, - STATE(2371), 1, - aux_sym_for_statement_repeat1, - STATE(2402), 2, + STATE(2892), 2, sym_comment, sym_include, - [101009] = 5, - ACTIONS(373), 1, + ACTIONS(1464), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118461] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2403), 2, + STATE(2893), 2, sym_comment, sym_include, - ACTIONS(1284), 3, + ACTIONS(1460), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [101028] = 5, - ACTIONS(373), 1, + [118480] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2404), 2, + STATE(2894), 2, sym_comment, sym_include, - ACTIONS(1218), 3, + ACTIONS(1456), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [101047] = 5, - ACTIONS(373), 1, + [118499] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2405), 2, + STATE(2895), 2, sym_comment, sym_include, - ACTIONS(3443), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [101066] = 7, - ACTIONS(373), 1, + ACTIONS(1452), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118518] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2874), 1, - anon_sym_COLON, - STATE(2386), 1, - aux_sym_for_statement_repeat1, - STATE(2406), 2, + STATE(2896), 2, sym_comment, sym_include, - [101089] = 7, + ACTIONS(1448), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118537] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3445), 1, + ACTIONS(4191), 1, sym_identifier, - ACTIONS(3447), 1, - aux_sym_class_statement_token1, - STATE(3205), 1, - sym_qualified_name, - STATE(2407), 2, + ACTIONS(4193), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(2897), 2, sym_comment, sym_include, - [101112] = 7, - ACTIONS(373), 1, + [118558] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2874), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2408), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1697), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2898), 2, sym_comment, sym_include, - [101135] = 7, - ACTIONS(373), 1, + [118581] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2353), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2409), 2, + ACTIONS(67), 1, + sym__namedot, + ACTIONS(4195), 1, + sym__terminator, + STATE(2), 1, + aux_sym_qualified_name_repeat1, + STATE(2899), 2, sym_comment, sym_include, - [101158] = 5, - ACTIONS(373), 1, + [118604] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2410), 2, + ACTIONS(3884), 1, + sym__integer_literal, + STATE(1703), 1, + sym_number_literal, + STATE(1932), 1, + sym__decimal_literal, + STATE(2900), 2, sym_comment, sym_include, - ACTIONS(1218), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101177] = 7, - ACTIONS(373), 1, + [118627] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2353), 1, - anon_sym_COLON, - STATE(2474), 1, - aux_sym_for_statement_repeat1, - STATE(2411), 2, + ACTIONS(4197), 1, + anon_sym_RPAREN, + STATE(2669), 1, + aux_sym_function_statement_repeat1, + STATE(2901), 2, sym_comment, sym_include, - [101200] = 7, - ACTIONS(373), 1, + [118650] = 7, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1960), 1, - anon_sym_COLON, - STATE(2373), 1, - aux_sym_for_statement_repeat1, - STATE(2412), 2, + ACTIONS(4199), 1, + sym_identifier, + ACTIONS(4201), 1, + aux_sym_input_expression_token2, + STATE(900), 1, + sym_qualified_name, + STATE(2902), 2, sym_comment, sym_include, - [101223] = 5, - ACTIONS(373), 1, + [118673] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2413), 2, + STATE(2903), 2, sym_comment, sym_include, - ACTIONS(1218), 3, + ACTIONS(1444), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [101242] = 5, - ACTIONS(373), 1, + [118692] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2414), 2, + STATE(2904), 2, sym_comment, sym_include, - ACTIONS(1218), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101261] = 7, - ACTIONS(3), 1, + ACTIONS(4203), 3, + aux_sym_index_tuning_token2, + aux_sym_index_tuning_token3, + aux_sym_index_tuning_token4, + [118711] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3256), 1, - anon_sym_, - ACTIONS(3449), 1, - anon_sym_RPAREN, - STATE(2296), 1, - aux_sym_accumulate_statement_repeat1, - STATE(2415), 2, + ACTIONS(1278), 1, + anon_sym_COMMA, + ACTIONS(4099), 1, + anon_sym_COLON, + STATE(2685), 1, + aux_sym_for_statement_repeat1, + STATE(2905), 2, sym_comment, sym_include, - [101284] = 7, - ACTIONS(373), 1, + [118734] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1948), 1, + ACTIONS(2280), 1, + aux_sym_inherits_token1, + ACTIONS(3378), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2416), 2, + STATE(3388), 1, + sym_inherits, + STATE(2906), 2, sym_comment, sym_include, - [101307] = 5, - ACTIONS(373), 1, + [118757] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2417), 2, + STATE(2907), 2, sym_comment, sym_include, - ACTIONS(1222), 3, + ACTIONS(1436), 3, aux_sym__block_terminator_token1, aux_sym_case_when_branch_token1, aux_sym_case_otherwise_branch_token1, - [101326] = 7, - ACTIONS(373), 1, + [118776] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2038), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2418), 2, + ACTIONS(4197), 1, + anon_sym_RPAREN, + STATE(2774), 1, + aux_sym_function_statement_repeat1, + STATE(2908), 2, sym_comment, sym_include, - [101349] = 7, - ACTIONS(373), 1, + [118799] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3822), 1, anon_sym_COMMA, - ACTIONS(2040), 1, - anon_sym_COLON, - STATE(2329), 1, - aux_sym_for_statement_repeat1, - STATE(2419), 2, + ACTIONS(4205), 1, + anon_sym_RPAREN, + STATE(2754), 1, + aux_sym_function_statement_repeat1, + STATE(2909), 2, sym_comment, sym_include, - [101372] = 7, - ACTIONS(373), 1, + [118822] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2040), 1, + STATE(2910), 2, + sym_comment, + sym_include, + ACTIONS(4207), 3, + aux_sym_for_phrase_token1, + aux_sym_for_phrase_token2, + aux_sym_for_phrase_token3, + [118841] = 7, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3177), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2420), 2, + ACTIONS(3307), 1, + aux_sym_on_error_phrase_token1, + STATE(3460), 1, + sym_on_stop_phrase, + STATE(2911), 2, sym_comment, sym_include, - [101395] = 7, - ACTIONS(373), 1, + [118864] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3451), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2421), 2, + STATE(2912), 2, sym_comment, sym_include, - [101418] = 7, + ACTIONS(1440), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118883] = 7, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3453), 1, + ACTIONS(882), 1, + anon_sym_LPAREN, + ACTIONS(4209), 1, sym_identifier, - ACTIONS(3455), 1, - aux_sym_input_expression_token2, - STATE(635), 1, - sym_qualified_name, - STATE(2422), 2, + STATE(901), 1, + sym_parenthesized_expression, + STATE(2913), 2, sym_comment, sym_include, - [101441] = 7, - ACTIONS(373), 1, + [118906] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3457), 1, - anon_sym_COLON, - STATE(2395), 1, - aux_sym_for_statement_repeat1, - STATE(2423), 2, + ACTIONS(4211), 1, + sym_identifier, + ACTIONS(4214), 1, + anon_sym_RPAREN, + STATE(2914), 3, sym_comment, sym_include, - [101464] = 7, - ACTIONS(3), 1, + aux_sym_query_fields_repeat1, + [118927] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(756), 1, - anon_sym_LPAREN, - ACTIONS(3459), 1, - sym_identifier, - STATE(632), 1, - sym_parenthesized_expression, - STATE(2424), 2, + STATE(2915), 2, sym_comment, sym_include, - [101487] = 7, - ACTIONS(373), 1, + ACTIONS(1436), 3, + aux_sym__block_terminator_token1, + aux_sym_case_when_branch_token1, + aux_sym_case_otherwise_branch_token1, + [118946] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3457), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2425), 2, + ACTIONS(3113), 1, + aux_sym__block_terminator_token1, + STATE(1164), 1, + sym__block_terminator, + STATE(1221), 1, + sym__case_terminator, + STATE(2916), 2, sym_comment, sym_include, - [101510] = 7, - ACTIONS(373), 1, + [118969] = 7, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3183), 1, anon_sym_COMMA, - ACTIONS(2859), 1, - anon_sym_COLON, - STATE(2226), 1, - aux_sym_for_statement_repeat1, - STATE(2426), 2, + ACTIONS(3364), 1, + aux_sym_data_relation_token2, + STATE(2850), 1, + aux_sym_data_relation_repeat1, + STATE(2917), 2, sym_comment, sym_include, - [101533] = 7, + [118992] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(657), 1, - anon_sym_LPAREN, - ACTIONS(3461), 1, - sym_identifier, - STATE(527), 1, - sym_parenthesized_expression, - STATE(2427), 2, + STATE(2918), 2, sym_comment, sym_include, - [101556] = 7, - ACTIONS(373), 1, + ACTIONS(4216), 3, + sym_identifier, + sym__terminator, + anon_sym_NO_DASHERROR, + [119011] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + STATE(2919), 2, + sym_comment, + sym_include, + ACTIONS(4218), 3, anon_sym_COMMA, - ACTIONS(1940), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2428), 2, + aux_sym_on_error_phrase_token1, + [119030] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1395), 1, + sym__block_terminator, + STATE(2920), 2, sym_comment, sym_include, - [101579] = 7, - ACTIONS(373), 1, + [119050] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3463), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2429), 2, + ACTIONS(4222), 1, + sym_identifier, + STATE(2106), 1, + sym_qualified_name, + STATE(2921), 2, sym_comment, sym_include, - [101602] = 7, - ACTIONS(373), 1, + [119070] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2000), 1, - anon_sym_COLON, - STATE(2420), 1, - aux_sym_for_statement_repeat1, - STATE(2430), 2, + ACTIONS(4224), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(4226), 1, + aux_sym_function_statement_token1, + STATE(2922), 2, sym_comment, sym_include, - [101625] = 5, - ACTIONS(373), 1, + [119090] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2431), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2837), 1, + sym__block_terminator, + STATE(2923), 2, sym_comment, sym_include, - ACTIONS(1226), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101644] = 5, - ACTIONS(373), 1, + [119110] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2432), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2907), 1, + sym__block_terminator, + STATE(2924), 2, sym_comment, sym_include, - ACTIONS(1226), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101663] = 5, - ACTIONS(373), 1, + [119130] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2433), 2, + ACTIONS(4230), 1, + sym_identifier, + STATE(1488), 1, + sym_qualified_name, + STATE(2925), 2, sym_comment, sym_include, - ACTIONS(1226), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101682] = 7, - ACTIONS(373), 1, + [119150] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2044), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2434), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2915), 1, + sym__block_terminator, + STATE(2926), 2, sym_comment, sym_include, - [101705] = 7, - ACTIONS(373), 1, + [119170] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2044), 1, - anon_sym_COLON, - STATE(2524), 1, - aux_sym_for_statement_repeat1, - STATE(2435), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2912), 1, + sym__block_terminator, + STATE(2927), 2, sym_comment, sym_include, - [101728] = 5, - ACTIONS(373), 1, + [119190] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2436), 2, + ACTIONS(4232), 1, + aux_sym_variable_definition_token5, + ACTIONS(4234), 1, + aux_sym_function_parameter_token2, + STATE(2928), 2, sym_comment, sym_include, - ACTIONS(1226), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101747] = 7, - ACTIONS(373), 1, + [119210] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2724), 1, - anon_sym_COLON, - STATE(2457), 1, - aux_sym_for_statement_repeat1, - STATE(2437), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2903), 1, + sym__block_terminator, + STATE(2929), 2, sym_comment, sym_include, - [101770] = 7, - ACTIONS(373), 1, + [119230] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1978), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2438), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2896), 1, + sym__block_terminator, + STATE(2930), 2, sym_comment, sym_include, - [101793] = 5, - ACTIONS(373), 1, + [119250] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2439), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2895), 1, + sym__block_terminator, + STATE(2931), 2, sym_comment, sym_include, - ACTIONS(1230), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101812] = 5, - ACTIONS(373), 1, + [119270] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2440), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2894), 1, + sym__block_terminator, + STATE(2932), 2, sym_comment, sym_include, - ACTIONS(3465), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [101831] = 7, - ACTIONS(373), 1, + [119290] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2830), 1, - anon_sym_COLON, - STATE(2408), 1, - aux_sym_for_statement_repeat1, - STATE(2441), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2893), 1, + sym__block_terminator, + STATE(2933), 2, sym_comment, sym_include, - [101854] = 7, - ACTIONS(373), 1, + [119310] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1978), 1, - anon_sym_COLON, - STATE(2392), 1, - aux_sym_for_statement_repeat1, - STATE(2442), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1180), 1, + sym__block_terminator, + STATE(2934), 2, sym_comment, sym_include, - [101877] = 7, - ACTIONS(373), 1, + [119330] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2830), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2443), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2892), 1, + sym__block_terminator, + STATE(2935), 2, sym_comment, sym_include, - [101900] = 7, - ACTIONS(3), 1, + [119350] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3467), 1, - sym_identifier, - ACTIONS(3469), 1, - aux_sym_buffer_definition_token3, - STATE(3050), 1, - sym_qualified_name, - STATE(2444), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2891), 1, + sym__block_terminator, + STATE(2936), 2, sym_comment, sym_include, - [101923] = 5, - ACTIONS(373), 1, + [119370] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2445), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1375), 1, + sym__block_terminator, + STATE(2937), 2, sym_comment, sym_include, - ACTIONS(1234), 3, + [119390] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [101942] = 5, - ACTIONS(373), 1, + STATE(2890), 1, + sym__block_terminator, + STATE(2938), 2, + sym_comment, + sym_include, + [119410] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2446), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2888), 1, + sym__block_terminator, + STATE(2939), 2, sym_comment, sym_include, - ACTIONS(3471), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [101961] = 7, - ACTIONS(373), 1, + [119430] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3473), 1, + ACTIONS(4238), 2, sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2447), 2, + anon_sym_COLON, + STATE(2940), 2, sym_comment, sym_include, - [101984] = 7, - ACTIONS(3), 1, + [119448] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3475), 1, - sym_identifier, - ACTIONS(3477), 1, - aux_sym_input_expression_token2, - STATE(530), 1, - sym_qualified_name, - STATE(2448), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2887), 1, + sym__block_terminator, + STATE(2941), 2, sym_comment, sym_include, - [102007] = 5, - ACTIONS(373), 1, + [119468] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2449), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2875), 1, + sym__block_terminator, + STATE(2942), 2, sym_comment, sym_include, - ACTIONS(1238), 3, + [119488] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102026] = 7, - ACTIONS(373), 1, + STATE(2874), 1, + sym__block_terminator, + STATE(2943), 2, + sym_comment, + sym_include, + [119508] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3414), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1099), 1, - sym__function_terminator, - STATE(1182), 1, + STATE(1329), 1, sym__block_terminator, - STATE(2450), 2, + STATE(2944), 2, sym_comment, sym_include, - [102049] = 5, - ACTIONS(373), 1, + [119528] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2451), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2873), 1, + sym__block_terminator, + STATE(2945), 2, sym_comment, sym_include, - ACTIONS(1238), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102068] = 7, - ACTIONS(373), 1, + [119548] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2857), 1, - anon_sym_COLON, - STATE(2425), 1, - aux_sym_for_statement_repeat1, - STATE(2452), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2872), 1, + sym__block_terminator, + STATE(2946), 2, sym_comment, sym_include, - [102091] = 5, - ACTIONS(373), 1, + [119568] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2453), 2, + ACTIONS(4240), 1, + sym_identifier, + STATE(1707), 1, + sym_qualified_name, + STATE(2947), 2, sym_comment, sym_include, - ACTIONS(1238), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102110] = 7, - ACTIONS(373), 1, + [119588] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3479), 1, - anon_sym_COLON, - STATE(3153), 1, - sym_on_stop_phrase, - STATE(2454), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2865), 1, + sym__block_terminator, + STATE(2948), 2, sym_comment, sym_include, - [102133] = 7, - ACTIONS(373), 1, + [119608] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2857), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2455), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2861), 1, + sym__block_terminator, + STATE(2949), 2, sym_comment, sym_include, - [102156] = 7, - ACTIONS(373), 1, + [119628] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3481), 1, - anon_sym_COLON, - STATE(3154), 1, - sym_on_stop_phrase, - STATE(2456), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2857), 1, + sym__block_terminator, + STATE(2950), 2, sym_comment, sym_include, - [102179] = 7, - ACTIONS(373), 1, + [119648] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2859), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2457), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1333), 1, + sym__block_terminator, + STATE(2951), 2, sym_comment, sym_include, - [102202] = 5, - ACTIONS(373), 1, + [119668] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2458), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1334), 1, + sym__block_terminator, + STATE(2952), 2, sym_comment, sym_include, - ACTIONS(3483), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [102221] = 7, - ACTIONS(373), 1, + [119688] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1940), 1, - anon_sym_COLON, - STATE(2298), 1, - aux_sym_for_statement_repeat1, - STATE(2459), 2, + ACTIONS(4242), 1, + sym__terminator, + ACTIONS(4244), 1, + aux_sym_class_statement_token1, + STATE(2953), 2, sym_comment, sym_include, - [102244] = 5, - ACTIONS(373), 1, + [119708] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2460), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1358), 1, + sym__block_terminator, + STATE(2954), 2, sym_comment, sym_include, - ACTIONS(1238), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102263] = 5, - ACTIONS(373), 1, + [119728] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2461), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1359), 1, + sym__block_terminator, + STATE(2955), 2, sym_comment, sym_include, - ACTIONS(1238), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102282] = 5, - ACTIONS(373), 1, + [119748] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2462), 2, + ACTIONS(4246), 1, + sym_identifier, + STATE(637), 1, + sym_function_call, + STATE(2956), 2, sym_comment, sym_include, - ACTIONS(3485), 3, - anon_sym_COMMA, - anon_sym_COLON, - aux_sym_on_error_phrase_token1, - [102301] = 5, - ACTIONS(373), 1, + [119768] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2463), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1361), 1, + sym__block_terminator, + STATE(2957), 2, sym_comment, sym_include, - ACTIONS(1238), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102320] = 5, - ACTIONS(373), 1, + [119788] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2464), 2, + ACTIONS(4248), 2, + sym__terminator, + anon_sym_COLON, + STATE(2958), 2, sym_comment, sym_include, - ACTIONS(1242), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102339] = 7, - ACTIONS(373), 1, + [119806] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2872), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2465), 2, + ACTIONS(4250), 1, + anon_sym_DOT, + ACTIONS(4252), 1, + aux_sym__function_terminator_token1, + STATE(2959), 2, sym_comment, sym_include, - [102362] = 7, - ACTIONS(373), 1, + [119826] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3487), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2466), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1362), 1, + sym__block_terminator, + STATE(2960), 2, sym_comment, sym_include, - [102385] = 7, - ACTIONS(373), 1, + [119846] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2872), 1, - anon_sym_COLON, - STATE(2508), 1, - aux_sym_for_statement_repeat1, - STATE(2467), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1183), 1, + sym__block_terminator, + STATE(2961), 2, sym_comment, sym_include, - [102408] = 7, - ACTIONS(373), 1, + [119866] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1974), 1, - anon_sym_COLON, - STATE(2557), 1, - aux_sym_for_statement_repeat1, - STATE(2468), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1380), 1, + sym__block_terminator, + STATE(2962), 2, sym_comment, sym_include, - [102431] = 7, + [119886] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3256), 1, - anon_sym_, - ACTIONS(3489), 1, - anon_sym_RPAREN, - STATE(2415), 1, - aux_sym_accumulate_statement_repeat1, - STATE(2469), 2, + ACTIONS(4254), 1, + sym_identifier, + STATE(655), 1, + sym_qualified_name, + STATE(2963), 2, sym_comment, sym_include, - [102454] = 5, - ACTIONS(373), 1, + [119906] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2470), 2, + ACTIONS(4256), 1, + sym_identifier, + ACTIONS(4258), 1, + anon_sym_COMMA, + STATE(2964), 2, sym_comment, sym_include, - ACTIONS(1246), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102473] = 7, - ACTIONS(373), 1, + [119926] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1964), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2471), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1185), 1, + sym__block_terminator, + STATE(2965), 2, sym_comment, sym_include, - [102496] = 7, + [119946] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3491), 1, + ACTIONS(3535), 1, + anon_sym_COLON, + ACTIONS(4260), 1, sym_identifier, - ACTIONS(3493), 1, - anon_sym_AMP, - ACTIONS(3495), 1, - sym__integer_literal, - STATE(2472), 2, + STATE(2966), 2, sym_comment, sym_include, - [102519] = 5, - ACTIONS(373), 1, + [119966] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2473), 2, - sym_comment, - sym_include, - ACTIONS(1250), 3, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102538] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2762), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2474), 2, + STATE(1392), 1, + sym__block_terminator, + STATE(2967), 2, sym_comment, sym_include, - [102561] = 5, - ACTIONS(373), 1, + [119986] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2475), 2, + ACTIONS(4262), 1, + anon_sym_DOT, + ACTIONS(4264), 1, + aux_sym__case_terminator_token1, + STATE(2968), 2, sym_comment, sym_include, - ACTIONS(3497), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [102580] = 5, - ACTIONS(373), 1, + [120006] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2476), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1406), 1, + sym__block_terminator, + STATE(2969), 2, sym_comment, sym_include, - ACTIONS(1254), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102599] = 5, - ACTIONS(373), 1, + [120026] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2477), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2823), 1, + sym__block_terminator, + STATE(2970), 2, sym_comment, sym_include, - ACTIONS(1258), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102618] = 5, - ACTIONS(373), 1, + [120046] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2478), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2822), 1, + sym__block_terminator, + STATE(2971), 2, sym_comment, sym_include, - ACTIONS(1258), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102637] = 5, - ACTIONS(373), 1, + [120066] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2479), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1188), 1, + sym__block_terminator, + STATE(2972), 2, sym_comment, sym_include, - ACTIONS(1258), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102656] = 7, - ACTIONS(373), 1, + [120086] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2379), 1, - anon_sym_COLON, - STATE(2443), 1, - aux_sym_for_statement_repeat1, - STATE(2480), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2738), 1, + sym__block_terminator, + STATE(2973), 2, sym_comment, sym_include, - [102679] = 7, - ACTIONS(373), 1, + [120106] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2379), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2481), 2, + ACTIONS(4266), 1, + aux_sym_procedure_parameter_definition_token1, + ACTIONS(4268), 1, + aux_sym_function_statement_token1, + STATE(2974), 2, sym_comment, sym_include, - [102702] = 7, - ACTIONS(373), 1, + [120126] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2762), 1, - anon_sym_COLON, - STATE(2521), 1, - aux_sym_for_statement_repeat1, - STATE(2482), 2, + ACTIONS(4270), 1, + aux_sym_on_error_phrase_token1, + STATE(3805), 1, + sym_on_error_phrase, + STATE(2975), 2, sym_comment, sym_include, - [102725] = 7, - ACTIONS(373), 1, + [120146] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3499), 1, - anon_sym_COLON, - STATE(2980), 1, - sym_on_stop_phrase, - STATE(2483), 2, + ACTIONS(4272), 1, + sym_identifier, + STATE(2361), 1, + sym_qualified_name, + STATE(2976), 2, sym_comment, sym_include, - [102748] = 7, - ACTIONS(373), 1, + [120166] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3501), 1, - anon_sym_COLON, - STATE(3177), 1, - sym_on_stop_phrase, - STATE(2484), 2, + ACTIONS(4274), 1, + sym_identifier, + STATE(1678), 1, + sym_qualified_name, + STATE(2977), 2, sym_comment, sym_include, - [102771] = 5, - ACTIONS(373), 1, + [120186] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2485), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1374), 1, + sym__block_terminator, + STATE(2978), 2, sym_comment, sym_include, - ACTIONS(1258), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102790] = 5, - ACTIONS(373), 1, + [120206] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2486), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2692), 1, + sym__block_terminator, + STATE(2979), 2, sym_comment, sym_include, - ACTIONS(3503), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [102809] = 5, - ACTIONS(373), 1, + [120226] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2487), 2, + ACTIONS(4276), 1, + sym_identifier, + STATE(3725), 1, + sym_qualified_name, + STATE(2980), 2, sym_comment, sym_include, - ACTIONS(1262), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [102828] = 7, - ACTIONS(373), 1, + [120246] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1968), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2488), 2, + ACTIONS(4278), 1, + sym__terminator, + ACTIONS(4280), 1, + aux_sym_interface_statement_token1, + STATE(2981), 2, sym_comment, sym_include, - [102851] = 7, - ACTIONS(373), 1, + [120266] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2020), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2489), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2688), 1, + sym__block_terminator, + STATE(2982), 2, sym_comment, sym_include, - [102874] = 7, - ACTIONS(373), 1, + [120286] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3505), 1, - anon_sym_COLON, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2490), 2, + ACTIONS(4282), 1, + sym_identifier, + STATE(862), 1, + sym_function_call, + STATE(2983), 2, sym_comment, sym_include, - [102897] = 7, - ACTIONS(373), 1, + [120306] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2020), 1, - anon_sym_COLON, - STATE(2339), 1, - aux_sym_for_statement_repeat1, - STATE(2491), 2, + ACTIONS(4284), 1, + sym_identifier, + ACTIONS(4286), 1, + aux_sym_input_expression_token2, + STATE(2984), 2, sym_comment, sym_include, - [102920] = 7, - ACTIONS(373), 1, + [120326] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1988), 1, - anon_sym_COLON, - STATE(2231), 1, - aux_sym_for_statement_repeat1, - STATE(2492), 2, + ACTIONS(4288), 1, + sym__terminator, + ACTIONS(4290), 1, + aux_sym_catch_statement_token1, + STATE(2985), 2, sym_comment, sym_include, - [102943] = 5, - ACTIONS(373), 1, + [120346] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2493), 2, + ACTIONS(3483), 1, + anon_sym_COLON, + ACTIONS(4292), 1, + sym_identifier, + STATE(2986), 2, sym_comment, sym_include, - ACTIONS(3507), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [102962] = 7, - ACTIONS(373), 1, + [120366] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, + ACTIONS(67), 1, sym__namedot, - ACTIONS(3509), 1, - sym__terminator, - STATE(275), 1, + STATE(2), 1, aux_sym_qualified_name_repeat1, - STATE(2494), 2, + STATE(2987), 2, sym_comment, sym_include, - [102985] = 7, - ACTIONS(373), 1, + [120386] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3414), 1, - aux_sym__block_terminator_token1, - STATE(1074), 1, - sym__function_terminator, - STATE(1182), 1, - sym__block_terminator, - STATE(2495), 2, + ACTIONS(4294), 1, + sym_identifier, + STATE(888), 1, + sym_qualified_name, + STATE(2988), 2, sym_comment, sym_include, - [103008] = 5, - ACTIONS(373), 1, + [120406] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2496), 2, + ACTIONS(4296), 1, + aux_sym_access_tuning_token1, + ACTIONS(4298), 1, + anon_sym_COLON, + STATE(2989), 2, sym_comment, sym_include, - ACTIONS(3511), 3, - sym__terminator, - aux_sym_field_definition_token1, - aux_sym_index_definition_token1, - [103027] = 7, - ACTIONS(373), 1, + [120426] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3513), 1, - anon_sym_COLON, - STATE(3095), 1, - sym_on_stop_phrase, - STATE(2497), 2, + ACTIONS(4300), 1, + aux_sym_variable_definition_token5, + ACTIONS(4302), 1, + aux_sym_variable_definition_token6, + STATE(2990), 2, sym_comment, sym_include, - [103050] = 5, - ACTIONS(373), 1, + [120446] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2498), 2, + ACTIONS(4304), 1, + sym__terminator, + ACTIONS(4306), 1, + aux_sym_catch_statement_token1, + STATE(2991), 2, sym_comment, sym_include, - ACTIONS(1266), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103069] = 5, - ACTIONS(373), 1, + [120466] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2499), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2581), 1, + sym__block_terminator, + STATE(2992), 2, sym_comment, sym_include, - ACTIONS(1270), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103088] = 5, - ACTIONS(373), 1, + [120486] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2500), 2, + ACTIONS(4308), 1, + sym_identifier, + STATE(3679), 1, + sym_qualified_name, + STATE(2993), 2, sym_comment, sym_include, - ACTIONS(1274), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103107] = 5, - ACTIONS(373), 1, + [120506] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2501), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2497), 1, + sym__block_terminator, + STATE(2994), 2, sym_comment, sym_include, - ACTIONS(1278), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103126] = 7, - ACTIONS(373), 1, + [120526] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1968), 1, - anon_sym_COLON, - STATE(2438), 1, - aux_sym_for_statement_repeat1, - STATE(2502), 2, + ACTIONS(4310), 1, + sym_identifier, + STATE(3649), 1, + sym_qualified_name, + STATE(2995), 2, sym_comment, sym_include, - [103149] = 7, - ACTIONS(373), 1, + [120546] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3515), 1, - anon_sym_COLON, - STATE(3094), 1, - sym_on_stop_phrase, - STATE(2503), 2, + ACTIONS(4312), 1, + sym_identifier, + ACTIONS(4314), 1, + sym__integer_literal, + STATE(2996), 2, sym_comment, sym_include, - [103172] = 7, + [120566] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3256), 1, - anon_sym_, - ACTIONS(3517), 1, - anon_sym_RPAREN, - STATE(2296), 1, - aux_sym_accumulate_statement_repeat1, - STATE(2504), 2, + ACTIONS(4316), 1, + sym_identifier, + STATE(3671), 1, + sym_qualified_name, + STATE(2997), 2, + sym_comment, + sym_include, + [120586] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2499), 1, + sym__block_terminator, + STATE(2998), 2, sym_comment, sym_include, - [103195] = 7, + [120606] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3519), 1, + ACTIONS(4318), 1, sym_identifier, - ACTIONS(3521), 1, - aux_sym_buffer_definition_token3, - STATE(3029), 1, + STATE(1481), 1, sym_qualified_name, - STATE(2505), 2, + STATE(2999), 2, sym_comment, sym_include, - [103218] = 7, - ACTIONS(373), 1, + [120626] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1944), 1, - anon_sym_COLON, - STATE(2369), 1, - aux_sym_for_statement_repeat1, - STATE(2506), 2, + ACTIONS(4320), 1, + sym_identifier, + STATE(1479), 1, + sym_qualified_name, + STATE(3000), 2, sym_comment, sym_include, - [103241] = 7, - ACTIONS(373), 1, + [120646] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1944), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2507), 2, + ACTIONS(4322), 1, + sym_identifier, + STATE(3537), 1, + sym_qualified_name, + STATE(3001), 2, sym_comment, sym_include, - [103264] = 7, - ACTIONS(373), 1, + [120666] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3523), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2508), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2500), 1, + sym__block_terminator, + STATE(3002), 2, sym_comment, sym_include, - [103287] = 7, - ACTIONS(373), 1, + [120686] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3523), 1, - anon_sym_COLON, - STATE(2546), 1, - aux_sym_for_statement_repeat1, - STATE(2509), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2502), 1, + sym__block_terminator, + STATE(3003), 2, sym_comment, sym_include, - [103310] = 7, - ACTIONS(373), 1, + [120706] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1986), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2510), 2, + ACTIONS(4324), 1, + sym_identifier, + STATE(1487), 1, + sym_qualified_name, + STATE(3004), 2, sym_comment, sym_include, - [103333] = 7, + [120726] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3525), 1, + ACTIONS(4326), 1, sym_identifier, - ACTIONS(3527), 1, - aux_sym_buffer_definition_token3, - STATE(3055), 1, + STATE(1478), 1, sym_qualified_name, - STATE(2511), 2, + STATE(3005), 2, sym_comment, sym_include, - [103356] = 5, - ACTIONS(373), 1, + [120746] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2512), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1328), 1, + sym__block_terminator, + STATE(3006), 2, sym_comment, sym_include, - ACTIONS(1304), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103375] = 5, - ACTIONS(373), 1, + [120766] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2513), 2, + ACTIONS(4270), 1, + aux_sym_on_error_phrase_token1, + STATE(3637), 1, + sym_on_error_phrase, + STATE(3007), 2, sym_comment, sym_include, - ACTIONS(1306), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103394] = 5, - ACTIONS(373), 1, + [120786] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2514), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2510), 1, + sym__block_terminator, + STATE(3008), 2, sym_comment, sym_include, - ACTIONS(1310), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103413] = 7, - ACTIONS(373), 1, + [120806] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2776), 1, - anon_sym_COLON, - STATE(2455), 1, - aux_sym_for_statement_repeat1, - STATE(2515), 2, + ACTIONS(4328), 1, + sym_identifier, + STATE(3405), 1, + sym_qualified_name, + STATE(3009), 2, sym_comment, sym_include, - [103436] = 7, - ACTIONS(373), 1, + [120826] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2776), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2516), 2, + ACTIONS(4262), 1, + anon_sym_DOT, + ACTIONS(4330), 1, + aux_sym__procedure_terminator_token1, + STATE(3010), 2, sym_comment, sym_include, - [103459] = 7, + [120846] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3529), 1, + ACTIONS(4332), 1, sym_identifier, - ACTIONS(3531), 1, - aux_sym_buffer_definition_token3, - STATE(3109), 1, + STATE(1483), 1, sym_qualified_name, - STATE(2517), 2, + STATE(3011), 2, sym_comment, sym_include, - [103482] = 5, - ACTIONS(373), 1, + [120866] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2518), 2, + ACTIONS(4334), 1, + sym_identifier, + STATE(1484), 1, + sym_qualified_name, + STATE(3012), 2, sym_comment, sym_include, - ACTIONS(1314), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103501] = 7, - ACTIONS(373), 1, + [120886] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3533), 1, - anon_sym_COLON, - STATE(3021), 1, - sym_on_stop_phrase, - STATE(2519), 2, + ACTIONS(4336), 1, + sym_identifier, + STATE(3491), 1, + sym_qualified_name, + STATE(3013), 2, sym_comment, sym_include, - [103524] = 7, - ACTIONS(373), 1, + [120906] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3037), 1, - anon_sym_COLON, - STATE(3211), 1, - sym_on_stop_phrase, - STATE(2520), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2512), 1, + sym__block_terminator, + STATE(3014), 2, sym_comment, sym_include, - [103547] = 7, - ACTIONS(373), 1, + [120926] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2970), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2521), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1211), 1, + sym__block_terminator, + STATE(3015), 2, sym_comment, sym_include, - [103570] = 7, - ACTIONS(373), 1, + [120946] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3535), 1, - anon_sym_COLON, - STATE(3213), 1, - sym_on_stop_phrase, - STATE(2522), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1210), 1, + sym__block_terminator, + STATE(3016), 2, sym_comment, sym_include, - [103593] = 7, - ACTIONS(373), 1, + [120966] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1974), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2523), 2, + ACTIONS(4338), 1, + aux_sym_variable_definition_token5, + ACTIONS(4340), 1, + aux_sym_variable_definition_token6, + STATE(3017), 2, sym_comment, sym_include, - [103616] = 7, - ACTIONS(373), 1, + [120986] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2050), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2524), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2515), 1, + sym__block_terminator, + STATE(3018), 2, sym_comment, sym_include, - [103639] = 7, - ACTIONS(373), 1, + [121006] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - ACTIONS(3537), 1, - anon_sym_COLON, - STATE(3082), 1, - sym_on_stop_phrase, - STATE(2525), 2, + ACTIONS(4342), 1, + sym_identifier, + STATE(1486), 1, + sym_qualified_name, + STATE(3019), 2, sym_comment, sym_include, - [103662] = 7, - ACTIONS(373), 1, + [121026] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1990), 1, - anon_sym_COLON, - STATE(2276), 1, - aux_sym_for_statement_repeat1, - STATE(2526), 2, + ACTIONS(4344), 1, + sym_identifier, + STATE(1665), 1, + sym_qualified_name, + STATE(3020), 2, sym_comment, sym_include, - [103685] = 7, - ACTIONS(373), 1, + [121046] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1946), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2527), 2, + ACTIONS(4346), 1, + aux_sym_variable_definition_token5, + ACTIONS(4348), 1, + aux_sym_variable_definition_token6, + STATE(3021), 2, sym_comment, sym_include, - [103708] = 7, - ACTIONS(373), 1, + [121066] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(3392), 2, anon_sym_COMMA, - ACTIONS(2970), 1, anon_sym_COLON, - STATE(2547), 1, - aux_sym_for_statement_repeat1, - STATE(2528), 2, + STATE(3022), 2, sym_comment, sym_include, - [103731] = 5, - ACTIONS(373), 1, + [121084] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2529), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1303), 1, + sym__block_terminator, + STATE(3023), 2, sym_comment, sym_include, - ACTIONS(1382), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103750] = 7, - ACTIONS(373), 1, + [121104] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2373), 1, + ACTIONS(4350), 1, + aux_sym_access_tuning_token1, + ACTIONS(4352), 1, anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2530), 2, + STATE(3024), 2, sym_comment, sym_include, - [103773] = 7, - ACTIONS(373), 1, + [121124] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2375), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2531), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1214), 1, + sym__block_terminator, + STATE(3025), 2, sym_comment, sym_include, - [103796] = 7, - ACTIONS(373), 1, + [121144] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3539), 1, - anon_sym_LPAREN, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2532), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1209), 1, + sym__block_terminator, + STATE(3026), 2, sym_comment, sym_include, - [103819] = 5, - ACTIONS(373), 1, + [121164] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2533), 2, + ACTIONS(4354), 1, + sym_identifier, + STATE(1702), 1, + sym_qualified_name, + STATE(3027), 2, sym_comment, sym_include, - ACTIONS(3541), 3, - aux_sym_for_phrase_token1, - aux_sym_for_phrase_token2, - aux_sym_for_phrase_token3, - [103838] = 5, - ACTIONS(373), 1, + [121184] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2534), 2, + ACTIONS(4002), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3028), 2, sym_comment, sym_include, - ACTIONS(1386), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103857] = 6, + [121202] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3543), 1, + ACTIONS(4356), 1, sym_identifier, - ACTIONS(3546), 1, - anon_sym_RPAREN, - STATE(2535), 3, + STATE(525), 1, + sym_function_call, + STATE(3029), 2, sym_comment, sym_include, - aux_sym_query_fields_repeat1, - [103878] = 5, - ACTIONS(373), 1, + [121222] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2536), 2, - sym_comment, - sym_include, - ACTIONS(1392), 3, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103897] = 7, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3548), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2537), 2, + STATE(1215), 1, + sym__block_terminator, + STATE(3030), 2, sym_comment, sym_include, - [103920] = 6, + [121242] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3550), 1, + ACTIONS(4358), 1, sym_identifier, - ACTIONS(3552), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2538), 2, + ACTIONS(4360), 1, + sym__integer_literal, + STATE(3031), 2, sym_comment, sym_include, - [103941] = 5, - ACTIONS(373), 1, + [121262] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - STATE(2539), 2, + ACTIONS(4362), 1, + sym_identifier, + STATE(1476), 1, + sym_qualified_name, + STATE(3032), 2, sym_comment, sym_include, - ACTIONS(1406), 3, - aux_sym__block_terminator_token1, - aux_sym_case_when_branch_token1, - aux_sym_case_otherwise_branch_token1, - [103960] = 7, - ACTIONS(373), 1, + [121282] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2639), 1, - anon_sym_COLON, - ACTIONS(2832), 1, - aux_sym_on_error_phrase_token1, - STATE(3222), 1, - sym_on_stop_phrase, - STATE(2540), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1148), 1, + sym__block_terminator, + STATE(3033), 2, sym_comment, sym_include, - [103983] = 7, - ACTIONS(373), 1, + [121302] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2375), 1, - anon_sym_COLON, - STATE(2285), 1, - aux_sym_for_statement_repeat1, - STATE(2541), 2, + ACTIONS(4364), 1, + aux_sym_variable_definition_token5, + ACTIONS(4366), 1, + aux_sym_variable_definition_token6, + STATE(3034), 2, sym_comment, sym_include, - [104006] = 7, - ACTIONS(373), 1, + [121322] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2048), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2542), 2, + ACTIONS(4368), 1, + sym_identifier, + STATE(863), 1, + sym_function_call, + STATE(3035), 2, sym_comment, sym_include, - [104029] = 5, - ACTIONS(373), 1, + [121342] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - STATE(2543), 2, + ACTIONS(4370), 1, + aux_sym_input_close_statement_token2, + ACTIONS(4372), 1, + aux_sym_input_stream_statement_token1, + STATE(3036), 2, sym_comment, sym_include, - ACTIONS(3554), 3, - aux_sym_index_tuning_token2, - aux_sym_index_tuning_token3, - aux_sym_index_tuning_token4, - [104048] = 7, - ACTIONS(373), 1, + [121362] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - ACTIONS(3556), 1, - sym__terminator, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2544), 2, + ACTIONS(4372), 1, + aux_sym_input_stream_statement_token1, + ACTIONS(4374), 1, + aux_sym_input_close_statement_token2, + STATE(3037), 2, sym_comment, sym_include, - [104071] = 7, - ACTIONS(373), 1, + [121382] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3558), 1, - sym__integer_literal, - STATE(284), 1, - sym__decimal_literal, - STATE(2134), 1, - sym_number_literal, - STATE(2545), 2, + ACTIONS(4376), 1, + sym_identifier, + STATE(3693), 1, + sym_qualified_name, + STATE(3038), 2, sym_comment, sym_include, - [104094] = 7, - ACTIONS(373), 1, + [121402] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4378), 1, + sym_identifier, + ACTIONS(4380), 1, anon_sym_COMMA, - ACTIONS(3560), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2546), 2, + STATE(3039), 2, sym_comment, sym_include, - [104117] = 7, - ACTIONS(373), 1, + [121422] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3562), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2547), 2, + ACTIONS(4382), 1, + aux_sym_primitive_type_token1, + ACTIONS(4384), 1, + aux_sym_event_definition_token2, + STATE(3040), 2, sym_comment, sym_include, - [104140] = 7, - ACTIONS(373), 1, + [121442] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(3562), 1, - anon_sym_COLON, - STATE(2550), 1, - aux_sym_for_statement_repeat1, - STATE(2548), 2, + ACTIONS(4386), 1, + aux_sym_input_close_statement_token2, + ACTIONS(4388), 1, + aux_sym_output_stream_statement_token1, + STATE(3041), 2, sym_comment, sym_include, - [104163] = 7, - ACTIONS(373), 1, + [121462] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3252), 1, - anon_sym_COMMA, - ACTIONS(3564), 1, - anon_sym_RPAREN, - STATE(2199), 1, - aux_sym__function_call_arguments_repeat1, - STATE(2549), 2, + ACTIONS(4388), 1, + aux_sym_output_stream_statement_token1, + ACTIONS(4390), 1, + aux_sym_input_close_statement_token2, + STATE(3042), 2, sym_comment, sym_include, - [104186] = 7, - ACTIONS(373), 1, + [121482] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4392), 1, anon_sym_COMMA, - ACTIONS(3566), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2550), 2, + ACTIONS(4394), 1, + aux_sym_on_error_phrase_token3, + STATE(3043), 2, sym_comment, sym_include, - [104209] = 7, - ACTIONS(373), 1, + [121502] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2050), 1, - anon_sym_COLON, - STATE(2530), 1, - aux_sym_for_statement_repeat1, - STATE(2551), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1243), 1, + sym__block_terminator, + STATE(3044), 2, sym_comment, sym_include, - [104232] = 7, - ACTIONS(373), 1, + [121522] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4396), 2, + anon_sym_RPAREN, anon_sym_COMMA, - ACTIONS(1986), 1, - anon_sym_COLON, - STATE(2221), 1, - aux_sym_for_statement_repeat1, - STATE(2552), 2, + STATE(3045), 2, sym_comment, sym_include, - [104255] = 7, - ACTIONS(373), 1, + [121540] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2373), 1, - anon_sym_COLON, - STATE(2384), 1, - aux_sym_for_statement_repeat1, - STATE(2553), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2562), 1, + sym__block_terminator, + STATE(3046), 2, sym_comment, sym_include, - [104278] = 7, - ACTIONS(373), 1, + [121560] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, + ACTIONS(4398), 1, + sym_identifier, + ACTIONS(4400), 1, anon_sym_COMMA, - ACTIONS(2048), 1, - anon_sym_COLON, - STATE(2305), 1, - aux_sym_for_statement_repeat1, - STATE(2554), 2, + STATE(3047), 2, sym_comment, sym_include, - [104301] = 7, - ACTIONS(373), 1, + [121580] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(1946), 1, - anon_sym_COLON, - STATE(2377), 1, - aux_sym_for_statement_repeat1, - STATE(2555), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1147), 1, + sym__block_terminator, + STATE(3048), 2, sym_comment, sym_include, - [104324] = 7, + [121600] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3568), 1, + ACTIONS(4402), 1, sym_identifier, - ACTIONS(3570), 1, - anon_sym_AMP, - ACTIONS(3572), 1, + ACTIONS(4404), 1, sym__integer_literal, - STATE(2556), 2, + STATE(3049), 2, sym_comment, sym_include, - [104347] = 7, - ACTIONS(373), 1, + [121620] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1186), 1, - anon_sym_COMMA, - ACTIONS(2000), 1, - anon_sym_COLON, - STATE(2234), 1, - aux_sym_for_statement_repeat1, - STATE(2557), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1227), 1, + sym__block_terminator, + STATE(3050), 2, sym_comment, sym_include, - [104370] = 6, - ACTIONS(373), 1, + [121640] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1824), 1, - sym_query_fields, - STATE(2558), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2565), 1, + sym__block_terminator, + STATE(3051), 2, sym_comment, sym_include, - [104390] = 6, + [121660] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(1958), 1, - anon_sym_RPAREN, - ACTIONS(3576), 1, - anon_sym_, - STATE(2559), 2, + ACTIONS(4406), 1, + sym_identifier, + STATE(284), 1, + sym_qualified_name, + STATE(3052), 2, sym_comment, sym_include, - [104410] = 6, - ACTIONS(373), 1, + [121680] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3578), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(3580), 1, - aux_sym_function_statement_token1, - STATE(2560), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1228), 1, + sym__block_terminator, + STATE(3053), 2, sym_comment, sym_include, - [104430] = 6, - ACTIONS(373), 1, + [121700] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3582), 1, - aux_sym_on_error_phrase_token1, - STATE(2993), 1, - sym_on_error_phrase, - STATE(2561), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1179), 1, + sym__block_terminator, + STATE(3054), 2, + sym_comment, + sym_include, + [121720] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1322), 1, + sym__block_terminator, + STATE(3055), 2, sym_comment, sym_include, - [104450] = 6, + [121740] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3584), 1, + ACTIONS(4408), 1, sym_identifier, - ACTIONS(3586), 1, + ACTIONS(4410), 1, anon_sym_COMMA, - STATE(2562), 2, + STATE(3056), 2, sym_comment, sym_include, - [104470] = 6, - ACTIONS(373), 1, + [121760] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3582), 1, - aux_sym_on_error_phrase_token1, - STATE(3265), 1, - sym_on_error_phrase, - STATE(2563), 2, + ACTIONS(4412), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3057), 2, sym_comment, sym_include, - [104490] = 6, - ACTIONS(3), 1, + [121778] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3588), 1, - sym_identifier, - STATE(3252), 1, - sym_qualified_name, - STATE(2564), 2, + ACTIONS(4414), 1, + aux_sym_scope_tuning_token1, + STATE(3456), 1, + sym_new_expression, + STATE(3058), 2, sym_comment, sym_include, - [104510] = 6, + [121798] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3590), 1, + ACTIONS(4416), 1, sym_identifier, - STATE(1118), 1, - sym_qualified_name, - STATE(2565), 2, + ACTIONS(4418), 1, + anon_sym_COMMA, + STATE(3059), 2, sym_comment, sym_include, - [104530] = 6, - ACTIONS(373), 1, + [121818] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3592), 1, - aux_sym_access_tuning_token1, - ACTIONS(3594), 1, - anon_sym_COLON, - STATE(2566), 2, + ACTIONS(4420), 1, + sym__terminator, + ACTIONS(4422), 1, + aux_sym_catch_statement_token1, + STATE(3060), 2, sym_comment, sym_include, - [104550] = 6, - ACTIONS(373), 1, + [121838] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3596), 1, - aux_sym_procedure_parameter_definition_token1, - ACTIONS(3598), 1, - aux_sym_function_statement_token1, - STATE(2567), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2566), 1, + sym__block_terminator, + STATE(3061), 2, sym_comment, sym_include, - [104570] = 6, + [121858] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3600), 1, + ACTIONS(4424), 1, sym_identifier, - STATE(1567), 1, - sym_qualified_name, - STATE(2568), 2, + ACTIONS(4426), 1, + sym__integer_literal, + STATE(3062), 2, sym_comment, sym_include, - [104590] = 6, - ACTIONS(3), 1, + [121878] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3602), 1, - sym_identifier, - ACTIONS(3604), 1, - sym__integer_literal, - STATE(2569), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1335), 1, + sym__block_terminator, + STATE(3063), 2, sym_comment, sym_include, - [104610] = 6, + [121898] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3606), 1, + ACTIONS(4428), 1, sym_identifier, - STATE(623), 1, + STATE(745), 1, sym_function_call, - STATE(2570), 2, + STATE(3064), 2, sym_comment, sym_include, - [104630] = 6, + [121918] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3608), 1, + ACTIONS(4430), 1, sym_identifier, - STATE(410), 1, - sym_function_call, - STATE(2571), 2, - sym_comment, - sym_include, - [104650] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(1040), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(2572), 2, + STATE(278), 1, + sym_qualified_name, + STATE(3065), 2, sym_comment, sym_include, - [104668] = 6, - ACTIONS(373), 1, + [121938] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3610), 1, - aux_sym_input_close_statement_token2, - ACTIONS(3612), 1, - aux_sym_input_stream_statement_token1, - STATE(2573), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2571), 1, + sym__block_terminator, + STATE(3066), 2, sym_comment, sym_include, - [104688] = 6, - ACTIONS(373), 1, + [121958] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3612), 1, - aux_sym_input_stream_statement_token1, - ACTIONS(3614), 1, - aux_sym_input_close_statement_token2, - STATE(2574), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2578), 1, + sym__block_terminator, + STATE(3067), 2, sym_comment, sym_include, - [104708] = 6, - ACTIONS(373), 1, + [121978] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3616), 1, - aux_sym_variable_definition_token5, - ACTIONS(3618), 1, - aux_sym_variable_definition_token6, - STATE(2575), 2, + ACTIONS(4432), 1, + sym_identifier, + STATE(2426), 1, + sym_qualified_name, + STATE(3068), 2, sym_comment, sym_include, - [104728] = 6, - ACTIONS(373), 1, + [121998] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3620), 1, - aux_sym_access_tuning_token1, - ACTIONS(3622), 1, - anon_sym_COLON, - STATE(2576), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(949), 1, + sym__block_terminator, + STATE(3069), 2, sym_comment, sym_include, - [104748] = 6, + [122018] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3624), 1, + ACTIONS(4436), 1, sym_identifier, - STATE(3209), 1, + STATE(2162), 1, sym_qualified_name, - STATE(2577), 2, + STATE(3070), 2, sym_comment, sym_include, - [104768] = 6, - ACTIONS(373), 1, + [122038] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3626), 1, - aux_sym_do_statement_token1, - ACTIONS(3628), 1, - aux_sym_input_close_statement_token2, - STATE(2578), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(951), 1, + sym__block_terminator, + STATE(3071), 2, sym_comment, sym_include, - [104788] = 6, + [122058] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3630), 1, + ACTIONS(4438), 1, sym_identifier, - STATE(1574), 1, + STATE(306), 1, sym_qualified_name, - STATE(2579), 2, + STATE(3072), 2, sym_comment, sym_include, - [104808] = 6, - ACTIONS(373), 1, + [122078] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(2334), 1, + STATE(2585), 1, sym__block_terminator, - STATE(2580), 2, + STATE(3073), 2, sym_comment, sym_include, - [104828] = 6, - ACTIONS(373), 1, + [122098] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(2335), 1, + STATE(1205), 1, sym__block_terminator, - STATE(2581), 2, + STATE(3074), 2, sym_comment, sym_include, - [104848] = 6, - ACTIONS(3), 1, + [122118] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3634), 1, - sym_identifier, - ACTIONS(3636), 1, - sym__integer_literal, - STATE(2582), 2, + ACTIONS(1124), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(3075), 2, sym_comment, sym_include, - [104868] = 6, - ACTIONS(373), 1, + [122136] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3626), 1, - aux_sym_do_statement_token1, - ACTIONS(3638), 1, - aux_sym_input_close_statement_token2, - STATE(2583), 2, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2586), 1, + sym__block_terminator, + STATE(3076), 2, + sym_comment, + sym_include, + [122156] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4440), 1, + aux_sym_variable_definition_token5, + ACTIONS(4442), 1, + aux_sym_variable_definition_token6, + STATE(3077), 2, sym_comment, sym_include, - [104888] = 6, - ACTIONS(373), 1, + [122176] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2338), 1, + STATE(1146), 1, sym__block_terminator, - STATE(2584), 2, + STATE(3078), 2, sym_comment, sym_include, - [104908] = 6, - ACTIONS(3), 1, + [122196] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3640), 1, - sym_identifier, - STATE(3164), 1, - sym_qualified_name, - STATE(2585), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(953), 1, + sym__block_terminator, + STATE(3079), 2, sym_comment, sym_include, - [104928] = 6, - ACTIONS(373), 1, + [122216] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2340), 1, + STATE(957), 1, sym__block_terminator, - STATE(2586), 2, + STATE(3080), 2, sym_comment, sym_include, - [104948] = 6, - ACTIONS(373), 1, + [122236] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3642), 1, - aux_sym_input_close_statement_token2, - ACTIONS(3644), 1, - aux_sym_input_stream_statement_token1, - STATE(2587), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(958), 1, + sym__block_terminator, + STATE(3081), 2, sym_comment, sym_include, - [104968] = 6, - ACTIONS(373), 1, + [122256] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3644), 1, - aux_sym_input_stream_statement_token1, - ACTIONS(3646), 1, - aux_sym_input_close_statement_token2, - STATE(2588), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2093), 1, + sym_query_fields, + STATE(3082), 2, sym_comment, sym_include, - [104988] = 6, + [122276] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3648), 1, + ACTIONS(4446), 1, sym_identifier, - STATE(1015), 1, - sym_qualified_name, - STATE(2589), 2, + ACTIONS(4448), 1, + anon_sym_COMMA, + STATE(3083), 2, sym_comment, sym_include, - [105008] = 6, - ACTIONS(373), 1, + [122296] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2346), 1, - sym__block_terminator, - STATE(2590), 2, + ACTIONS(4450), 1, + sym_identifier, + ACTIONS(4452), 1, + anon_sym_COMMA, + STATE(3084), 2, sym_comment, sym_include, - [105028] = 6, - ACTIONS(373), 1, + [122316] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2347), 1, - sym__block_terminator, - STATE(2591), 2, + ACTIONS(2211), 1, + sym__namedot, + STATE(1758), 1, + aux_sym_qualified_name_repeat1, + STATE(3085), 2, sym_comment, sym_include, - [105048] = 6, - ACTIONS(373), 1, + [122336] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3650), 1, - aux_sym_do_statement_token1, - ACTIONS(3652), 1, - aux_sym_input_close_statement_token2, - STATE(2592), 2, + ACTIONS(2869), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3086), 2, sym_comment, sym_include, - [105068] = 6, - ACTIONS(373), 1, + [122354] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3650), 1, - aux_sym_do_statement_token1, - ACTIONS(3654), 1, - aux_sym_input_close_statement_token2, - STATE(2593), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1396), 1, + sym__block_terminator, + STATE(3087), 2, sym_comment, sym_include, - [105088] = 6, - ACTIONS(373), 1, + [122374] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3656), 1, - anon_sym_COMMA, - ACTIONS(3658), 1, - aux_sym_on_error_phrase_token3, - STATE(2594), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(960), 1, + sym__block_terminator, + STATE(3088), 2, sym_comment, sym_include, - [105108] = 6, - ACTIONS(373), 1, + [122394] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2348), 1, + STATE(961), 1, sym__block_terminator, - STATE(2595), 2, + STATE(3089), 2, + sym_comment, + sym_include, + [122414] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4228), 1, + aux_sym__block_terminator_token1, + STATE(2600), 1, + sym__block_terminator, + STATE(3090), 2, sym_comment, sym_include, - [105128] = 6, + [122434] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3660), 1, - sym_identifier, - STATE(1051), 1, - sym_qualified_name, - STATE(2596), 2, + ACTIONS(3928), 1, + anon_sym_RPAREN, + ACTIONS(4454), 1, + anon_sym_, + STATE(3091), 2, sym_comment, sym_include, - [105148] = 6, - ACTIONS(373), 1, + [122454] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2349), 1, - sym__block_terminator, - STATE(2597), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2127), 1, + sym_query_fields, + STATE(3092), 2, sym_comment, sym_include, - [105168] = 6, - ACTIONS(3), 1, + [122474] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3662), 1, - sym_identifier, - STATE(3042), 1, - sym_qualified_name, - STATE(2598), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1260), 1, + sym__block_terminator, + STATE(3093), 2, sym_comment, sym_include, - [105188] = 6, - ACTIONS(373), 1, + [122494] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2350), 1, + STATE(964), 1, sym__block_terminator, - STATE(2599), 2, + STATE(3094), 2, sym_comment, sym_include, - [105208] = 6, - ACTIONS(3), 1, + [122514] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3664), 1, - sym_identifier, - STATE(1252), 1, - sym_qualified_name, - STATE(2600), 2, + ACTIONS(4250), 1, + anon_sym_DOT, + ACTIONS(4456), 1, + aux_sym__case_terminator_token1, + STATE(3095), 2, sym_comment, sym_include, - [105228] = 6, - ACTIONS(373), 1, + [122534] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2353), 1, - sym__block_terminator, - STATE(2601), 2, + ACTIONS(4458), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3096), 2, + sym_comment, + sym_include, + [122552] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4414), 1, + aux_sym_scope_tuning_token1, + STATE(3543), 1, + sym_new_expression, + STATE(3097), 2, + sym_comment, + sym_include, + [122572] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2182), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3098), 2, sym_comment, sym_include, - [105248] = 6, - ACTIONS(373), 1, + [122590] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(2355), 1, + STATE(1306), 1, sym__block_terminator, - STATE(2602), 2, + STATE(3099), 2, sym_comment, sym_include, - [105268] = 6, - ACTIONS(373), 1, + [122610] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(2357), 1, + STATE(1172), 1, sym__block_terminator, - STATE(2603), 2, + STATE(3100), 2, sym_comment, sym_include, - [105288] = 5, - ACTIONS(373), 1, + [122630] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3666), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2604), 2, + ACTIONS(4460), 1, + sym__terminator, + ACTIONS(4462), 1, + aux_sym_class_statement_token1, + STATE(3101), 2, sym_comment, sym_include, - [105306] = 6, - ACTIONS(373), 1, + [122650] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3668), 1, - aux_sym_scope_tuning_token1, - STATE(3022), 1, - sym_new_expression, - STATE(2605), 2, + ACTIONS(4464), 1, + sym_identifier, + STATE(367), 1, + sym_function_call, + STATE(3102), 2, sym_comment, sym_include, - [105326] = 6, - ACTIONS(373), 1, + [122670] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(1100), 1, + STATE(2603), 1, sym__block_terminator, - STATE(2606), 2, + STATE(3103), 2, sym_comment, sym_include, - [105346] = 6, - ACTIONS(373), 1, + [122690] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2358), 1, + STATE(1139), 1, sym__block_terminator, - STATE(2607), 2, + STATE(3104), 2, sym_comment, sym_include, - [105366] = 6, - ACTIONS(373), 1, + [122710] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2359), 1, + STATE(965), 1, sym__block_terminator, - STATE(2608), 2, + STATE(3105), 2, sym_comment, sym_include, - [105386] = 6, - ACTIONS(3), 1, + [122730] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3672), 1, - sym_identifier, - STATE(1097), 1, - sym_qualified_name, - STATE(2609), 2, + ACTIONS(4466), 1, + sym__terminator, + ACTIONS(4468), 1, + aux_sym_catch_statement_token1, + STATE(3106), 2, sym_comment, sym_include, - [105406] = 6, - ACTIONS(373), 1, + [122750] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2360), 1, - sym__block_terminator, - STATE(2610), 2, + ACTIONS(4470), 1, + sym_identifier, + STATE(3506), 1, + sym_qualified_name, + STATE(3107), 2, sym_comment, sym_include, - [105426] = 6, + [122770] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3674), 1, + ACTIONS(4472), 1, sym_identifier, - STATE(270), 1, + STATE(2109), 1, sym_qualified_name, - STATE(2611), 2, + STATE(3108), 2, sym_comment, sym_include, - [105446] = 6, - ACTIONS(373), 1, + [122790] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2361), 1, - sym__block_terminator, - STATE(2612), 2, + ACTIONS(4474), 1, + sym__terminator, + ACTIONS(4476), 1, + aux_sym_catch_statement_token1, + STATE(3109), 2, sym_comment, sym_include, - [105466] = 6, - ACTIONS(373), 1, + [122810] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2364), 1, + STATE(967), 1, sym__block_terminator, - STATE(2613), 2, + STATE(3110), 2, sym_comment, sym_include, - [105486] = 6, - ACTIONS(3), 1, + [122830] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3676), 1, - sym_identifier, - STATE(3009), 1, - sym_qualified_name, - STATE(2614), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1138), 1, + sym__block_terminator, + STATE(3111), 2, sym_comment, sym_include, - [105506] = 6, - ACTIONS(373), 1, + [122850] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2365), 1, + STATE(968), 1, sym__block_terminator, - STATE(2615), 2, + STATE(3112), 2, sym_comment, sym_include, - [105526] = 6, - ACTIONS(3), 1, + [122870] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3678), 1, - sym_identifier, - STATE(1911), 1, - sym_qualified_name, - STATE(2616), 2, + ACTIONS(4414), 1, + aux_sym_scope_tuning_token1, + STATE(3513), 1, + sym_new_expression, + STATE(3113), 2, sym_comment, sym_include, - [105546] = 6, - ACTIONS(373), 1, + [122890] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3680), 1, - aux_sym_buffer_definition_token2, - ACTIONS(3682), 1, - aux_sym_repeat_statement_token1, - STATE(2617), 2, + ACTIONS(4478), 1, + sym__terminator, + ACTIONS(4480), 1, + aux_sym_interface_statement_token1, + STATE(3114), 2, sym_comment, sym_include, - [105566] = 6, - ACTIONS(373), 1, + [122910] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(2367), 1, + STATE(2608), 1, sym__block_terminator, - STATE(2618), 2, + STATE(3115), 2, sym_comment, sym_include, - [105586] = 6, - ACTIONS(373), 1, + [122930] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2368), 1, - sym__block_terminator, - STATE(2619), 2, + ACTIONS(4482), 1, + aux_sym_variable_definition_token5, + ACTIONS(4484), 1, + aux_sym_variable_definition_token6, + STATE(3116), 2, sym_comment, sym_include, - [105606] = 6, - ACTIONS(373), 1, + [122950] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2181), 1, + STATE(970), 1, sym__block_terminator, - STATE(2620), 2, + STATE(3117), 2, sym_comment, sym_include, - [105626] = 6, - ACTIONS(373), 1, + [122970] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(2372), 1, + STATE(1190), 1, sym__block_terminator, - STATE(2621), 2, + STATE(3118), 2, sym_comment, sym_include, - [105646] = 6, - ACTIONS(373), 1, + [122990] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2376), 1, - sym__block_terminator, - STATE(2622), 2, + ACTIONS(4250), 1, + anon_sym_DOT, + ACTIONS(4486), 1, + aux_sym__procedure_terminator_token1, + STATE(3119), 2, sym_comment, sym_include, - [105666] = 6, - ACTIONS(373), 1, + [123010] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(2381), 1, + STATE(1307), 1, sym__block_terminator, - STATE(2623), 2, + STATE(3120), 2, sym_comment, sym_include, - [105686] = 6, - ACTIONS(373), 1, + [123030] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2387), 1, - sym__block_terminator, - STATE(2624), 2, + ACTIONS(4488), 1, + aux_sym_input_close_statement_token2, + ACTIONS(4490), 1, + aux_sym_input_stream_statement_token1, + STATE(3121), 2, sym_comment, sym_include, - [105706] = 6, - ACTIONS(373), 1, + [123050] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2399), 1, + STATE(975), 1, sym__block_terminator, - STATE(2625), 2, + STATE(3122), 2, sym_comment, sym_include, - [105726] = 6, - ACTIONS(373), 1, + [123070] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2401), 1, + STATE(976), 1, sym__block_terminator, - STATE(2626), 2, + STATE(3123), 2, sym_comment, sym_include, - [105746] = 6, - ACTIONS(373), 1, + [123090] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2403), 1, + STATE(977), 1, sym__block_terminator, - STATE(2627), 2, + STATE(3124), 2, sym_comment, sym_include, - [105766] = 6, - ACTIONS(373), 1, + [123110] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2404), 1, + STATE(1468), 1, sym__block_terminator, - STATE(2628), 2, - sym_comment, - sym_include, - [105786] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(3684), 1, - sym_identifier, - ACTIONS(3686), 1, - anon_sym_COMMA, - STATE(2629), 2, + STATE(3125), 2, sym_comment, sym_include, - [105806] = 6, + [123130] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3688), 1, + ACTIONS(4492), 1, sym_identifier, - ACTIONS(3690), 1, - anon_sym_COMMA, - STATE(2630), 2, + STATE(3451), 1, + sym_qualified_name, + STATE(3126), 2, sym_comment, sym_include, - [105826] = 6, - ACTIONS(3), 1, + [123150] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3692), 1, - sym_identifier, - STATE(1172), 1, - sym_qualified_name, - STATE(2631), 2, + ACTIONS(4494), 1, + sym__terminator, + ACTIONS(4496), 1, + aux_sym_class_statement_token1, + STATE(3127), 2, sym_comment, sym_include, - [105846] = 6, - ACTIONS(373), 1, + [123170] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2413), 1, + STATE(979), 1, sym__block_terminator, - STATE(2632), 2, + STATE(3128), 2, sym_comment, sym_include, - [105866] = 6, + [123190] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3694), 1, + ACTIONS(4498), 1, sym_identifier, - STATE(1373), 1, + STATE(1482), 1, sym_qualified_name, - STATE(2633), 2, + STATE(3129), 2, + sym_comment, + sym_include, + [123210] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4490), 1, + aux_sym_input_stream_statement_token1, + ACTIONS(4500), 1, + aux_sym_input_close_statement_token2, + STATE(3130), 2, sym_comment, sym_include, - [105886] = 6, + [123230] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3696), 1, + ACTIONS(4502), 1, sym_identifier, - STATE(3123), 1, + STATE(912), 1, sym_qualified_name, - STATE(2634), 2, + STATE(3131), 2, sym_comment, sym_include, - [105906] = 6, - ACTIONS(373), 1, + [123250] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2414), 1, + STATE(980), 1, sym__block_terminator, - STATE(2635), 2, - sym_comment, - sym_include, - [105926] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3698), 1, - anon_sym_COMMA, - ACTIONS(3700), 1, - aux_sym_on_error_phrase_token3, - STATE(2636), 2, + STATE(3132), 2, sym_comment, sym_include, - [105946] = 6, - ACTIONS(373), 1, + [123270] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2417), 1, + STATE(1252), 1, sym__block_terminator, - STATE(2637), 2, + STATE(3133), 2, sym_comment, sym_include, - [105966] = 6, - ACTIONS(373), 1, + [123290] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2436), 1, - sym__block_terminator, - STATE(2638), 2, + ACTIONS(4504), 1, + sym_identifier, + STATE(2105), 1, + sym_qualified_name, + STATE(3134), 2, sym_comment, sym_include, - [105986] = 6, - ACTIONS(373), 1, + [123310] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2445), 1, + STATE(1253), 1, sym__block_terminator, - STATE(2639), 2, - sym_comment, - sym_include, - [106006] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3702), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2640), 2, + STATE(3135), 2, sym_comment, sym_include, - [106024] = 6, - ACTIONS(373), 1, + [123330] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3668), 1, - aux_sym_scope_tuning_token1, - STATE(3039), 1, - sym_new_expression, - STATE(2641), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1470), 1, + sym__block_terminator, + STATE(3136), 2, sym_comment, sym_include, - [106044] = 6, - ACTIONS(373), 1, + [123350] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2451), 1, - sym__block_terminator, - STATE(2642), 2, + ACTIONS(2186), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3137), 2, sym_comment, sym_include, - [106064] = 6, - ACTIONS(373), 1, + [123368] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2453), 1, - sym__block_terminator, - STATE(2643), 2, + ACTIONS(4506), 1, + sym_identifier, + STATE(3512), 1, + sym_qualified_name, + STATE(3138), 2, sym_comment, sym_include, - [106084] = 6, - ACTIONS(373), 1, + [123388] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(2463), 1, + STATE(2628), 1, sym__block_terminator, - STATE(2644), 2, + STATE(3139), 2, sym_comment, sym_include, - [106104] = 6, - ACTIONS(373), 1, + [123408] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2464), 1, - sym__block_terminator, - STATE(2645), 2, + ACTIONS(4508), 1, + sym__terminator, + ACTIONS(4510), 1, + aux_sym_interface_statement_token1, + STATE(3140), 2, sym_comment, sym_include, - [106124] = 6, - ACTIONS(373), 1, + [123428] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3388), 1, - aux_sym_on_stop_phrase_token1, - ACTIONS(3427), 1, - aux_sym_on_quit_phrase_token1, - STATE(2646), 2, + ACTIONS(4512), 1, + aux_sym_variable_definition_token5, + ACTIONS(4514), 1, + aux_sym_variable_definition_token6, + STATE(3141), 2, sym_comment, sym_include, - [106144] = 6, - ACTIONS(373), 1, + [123448] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3704), 1, - aux_sym_buffer_definition_token2, - ACTIONS(3706), 1, - aux_sym_repeat_statement_token1, - STATE(2647), 2, + ACTIONS(4516), 1, + sym__terminator, + ACTIONS(4518), 1, + aux_sym_catch_statement_token1, + STATE(3142), 2, sym_comment, sym_include, - [106164] = 6, - ACTIONS(373), 1, + [123468] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2473), 1, + STATE(982), 1, sym__block_terminator, - STATE(2648), 2, + STATE(3143), 2, sym_comment, sym_include, - [106184] = 6, - ACTIONS(373), 1, + [123488] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2476), 1, + STATE(1254), 1, sym__block_terminator, - STATE(2649), 2, + STATE(3144), 2, sym_comment, sym_include, - [106204] = 6, - ACTIONS(3), 1, + [123508] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3708), 1, - sym_identifier, - STATE(3048), 1, - sym_qualified_name, - STATE(2650), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2089), 1, + sym_query_fields, + STATE(3145), 2, sym_comment, sym_include, - [106224] = 6, - ACTIONS(3), 1, + [123528] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3710), 1, - sym_identifier, - STATE(1871), 1, - sym_qualified_name, - STATE(2651), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2103), 1, + sym_query_fields, + STATE(3146), 2, sym_comment, sym_include, - [106244] = 6, - ACTIONS(373), 1, + [123548] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(2485), 1, + STATE(1118), 1, sym__block_terminator, - STATE(2652), 2, - sym_comment, - sym_include, - [106264] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3712), 1, - aux_sym_variable_definition_token5, - ACTIONS(3714), 1, - aux_sym_variable_definition_token6, - STATE(2653), 2, + STATE(3147), 2, sym_comment, sym_include, - [106284] = 6, + [123568] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3716), 1, + ACTIONS(4520), 1, sym_identifier, - STATE(661), 1, + STATE(3772), 1, sym_qualified_name, - STATE(2654), 2, + STATE(3148), 2, sym_comment, sym_include, - [106304] = 6, + [123588] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3718), 1, + ACTIONS(4522), 1, sym_identifier, - STATE(1063), 1, - sym_qualified_name, - STATE(2655), 2, + ACTIONS(4524), 1, + sym__terminator, + STATE(3149), 2, sym_comment, sym_include, - [106324] = 6, - ACTIONS(373), 1, + [123608] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(1147), 1, + STATE(2630), 1, sym__block_terminator, - STATE(2656), 2, + STATE(3150), 2, sym_comment, sym_include, - [106344] = 6, - ACTIONS(373), 1, + [123628] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(2498), 1, + STATE(983), 1, sym__block_terminator, - STATE(2657), 2, + STATE(3151), 2, sym_comment, sym_include, - [106364] = 6, - ACTIONS(373), 1, + [123648] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3632), 1, - aux_sym__block_terminator_token1, - STATE(2500), 1, - sym__block_terminator, - STATE(2658), 2, + ACTIONS(4526), 1, + sym__terminator, + ACTIONS(4528), 1, + aux_sym_catch_statement_token1, + STATE(3152), 2, sym_comment, sym_include, - [106384] = 6, - ACTIONS(3), 1, + [123668] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3720), 1, - sym_identifier, - ACTIONS(3722), 1, + ACTIONS(4530), 1, sym__terminator, - STATE(2659), 2, + ACTIONS(4532), 1, + aux_sym_finally_statement_token1, + STATE(3153), 2, sym_comment, sym_include, - [106404] = 6, - ACTIONS(373), 1, + [123688] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(996), 1, + STATE(984), 1, sym__block_terminator, - STATE(2660), 2, + STATE(3154), 2, sym_comment, sym_include, - [106424] = 6, - ACTIONS(373), 1, + [123708] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3726), 1, - aux_sym_variable_definition_token5, - ACTIONS(3728), 1, - aux_sym_variable_definition_token6, - STATE(2661), 2, + ACTIONS(4534), 1, + sym_identifier, + STATE(2039), 1, + sym_qualified_name, + STATE(3155), 2, sym_comment, sym_include, - [106444] = 6, - ACTIONS(3), 1, + [123728] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3730), 1, - sym_identifier, - STATE(734), 1, - sym_function_call, - STATE(2662), 2, + ACTIONS(4536), 2, + sym__terminator, + anon_sym_COLON, + STATE(3156), 2, sym_comment, sym_include, - [106464] = 5, - ACTIONS(373), 1, + [123746] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3732), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2663), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1258), 1, + sym__block_terminator, + STATE(3157), 2, sym_comment, sym_include, - [106482] = 6, + [123766] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3734), 1, + ACTIONS(4538), 1, sym_identifier, - STATE(1536), 1, + STATE(2205), 1, sym_qualified_name, - STATE(2664), 2, + STATE(3158), 2, sym_comment, sym_include, - [106502] = 6, - ACTIONS(373), 1, + [123786] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3736), 1, - sym__terminator, - ACTIONS(3738), 1, - aux_sym_finally_statement_token1, - STATE(2665), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1414), 1, + sym__block_terminator, + STATE(3159), 2, sym_comment, sym_include, - [106522] = 6, - ACTIONS(3), 1, + [123806] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3740), 1, - sym_identifier, - STATE(1020), 1, - sym_qualified_name, - STATE(2666), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(988), 1, + sym__block_terminator, + STATE(3160), 2, sym_comment, sym_include, - [106542] = 6, - ACTIONS(3), 1, + [123826] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3742), 1, - sym_identifier, - STATE(1206), 1, - sym_qualified_name, - STATE(2667), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1256), 1, + sym__block_terminator, + STATE(3161), 2, sym_comment, sym_include, - [106562] = 6, - ACTIONS(3), 1, + [123846] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3744), 1, - sym_identifier, - STATE(3227), 1, - sym_qualified_name, - STATE(2668), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1062), 1, + sym__block_terminator, + STATE(3162), 2, sym_comment, sym_include, - [106582] = 6, + [123866] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3746), 1, + ACTIONS(4542), 1, sym_identifier, - ACTIONS(3748), 1, - anon_sym_COMMA, - STATE(2669), 2, + STATE(2217), 1, + sym_qualified_name, + STATE(3163), 2, sym_comment, sym_include, - [106602] = 6, + [123886] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3750), 1, + ACTIONS(4544), 1, sym_identifier, - ACTIONS(3752), 1, - sym__integer_literal, - STATE(2670), 2, + STATE(289), 1, + sym_qualified_name, + STATE(3164), 2, sym_comment, sym_include, - [106622] = 5, - ACTIONS(373), 1, + [123906] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3754), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(2671), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1259), 1, + sym__block_terminator, + STATE(3165), 2, sym_comment, sym_include, - [106640] = 6, - ACTIONS(373), 1, + [123926] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(928), 1, - sym__block_terminator, - STATE(2672), 2, + ACTIONS(4546), 1, + aux_sym_primitive_type_token1, + ACTIONS(4548), 1, + aux_sym_event_definition_token2, + STATE(3166), 2, sym_comment, sym_include, - [106660] = 6, - ACTIONS(373), 1, + [123946] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(997), 1, - sym__block_terminator, - STATE(2673), 2, + ACTIONS(4550), 1, + aux_sym_variable_definition_token5, + ACTIONS(4552), 1, + aux_sym_variable_definition_token6, + STATE(3167), 2, sym_comment, sym_include, - [106680] = 6, - ACTIONS(373), 1, + [123966] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(850), 1, - sym__block_terminator, - STATE(2674), 2, + ACTIONS(4554), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(3168), 2, sym_comment, sym_include, - [106700] = 6, + [123984] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3756), 1, + ACTIONS(3545), 1, + anon_sym_COLON, + ACTIONS(4556), 1, sym_identifier, - STATE(516), 1, - sym_qualified_name, - STATE(2675), 2, - sym_comment, - sym_include, - [106720] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(995), 1, - sym__block_terminator, - STATE(2676), 2, + STATE(3169), 2, sym_comment, sym_include, - [106740] = 6, - ACTIONS(373), 1, + [124004] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(994), 1, - sym__block_terminator, - STATE(2677), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2076), 1, + sym_query_fields, + STATE(3170), 2, sym_comment, sym_include, - [106760] = 6, - ACTIONS(373), 1, + [124024] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(993), 1, - sym__block_terminator, - STATE(2678), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2113), 1, + sym_query_fields, + STATE(3171), 2, sym_comment, sym_include, - [106780] = 6, - ACTIONS(373), 1, + [124044] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(992), 1, + STATE(987), 1, sym__block_terminator, - STATE(2679), 2, + STATE(3172), 2, sym_comment, sym_include, - [106800] = 6, - ACTIONS(373), 1, + [124064] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, STATE(991), 1, sym__block_terminator, - STATE(2680), 2, - sym_comment, - sym_include, - [106820] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(3758), 1, - sym_identifier, - STATE(262), 1, - sym_qualified_name, - STATE(2681), 2, + STATE(3173), 2, sym_comment, sym_include, - [106840] = 6, - ACTIONS(373), 1, + [124084] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(990), 1, + STATE(992), 1, sym__block_terminator, - STATE(2682), 2, - sym_comment, - sym_include, - [106860] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(3760), 1, - sym_identifier, - STATE(1944), 1, - sym_qualified_name, - STATE(2683), 2, - sym_comment, - sym_include, - [106880] = 6, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(3762), 1, - sym_identifier, - STATE(1828), 1, - sym_qualified_name, - STATE(2684), 2, + STATE(3174), 2, sym_comment, sym_include, - [106900] = 6, - ACTIONS(373), 1, + [124104] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(989), 1, + STATE(1266), 1, sym__block_terminator, - STATE(2685), 2, - sym_comment, - sym_include, - [106920] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1831), 1, - sym_query_fields, - STATE(2686), 2, + STATE(3175), 2, sym_comment, sym_include, - [106940] = 6, - ACTIONS(373), 1, + [124124] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1846), 1, - sym_query_fields, - STATE(2687), 2, + ACTIONS(4434), 1, + aux_sym__block_terminator_token1, + STATE(993), 1, + sym__block_terminator, + STATE(3176), 2, sym_comment, sym_include, - [106960] = 6, - ACTIONS(3), 1, + [124144] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3764), 1, - sym_identifier, - STATE(1844), 1, - sym_qualified_name, - STATE(2688), 2, + ACTIONS(4262), 1, + anon_sym_DOT, + ACTIONS(4558), 1, + aux_sym__function_terminator_token1, + STATE(3177), 2, sym_comment, sym_include, - [106980] = 6, + [124164] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3766), 1, + ACTIONS(4560), 1, sym_identifier, - STATE(3058), 1, - sym_qualified_name, - STATE(2689), 2, + ACTIONS(4562), 1, + sym__integer_literal, + STATE(3178), 2, sym_comment, sym_include, - [107000] = 6, - ACTIONS(373), 1, + [124184] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(988), 1, + STATE(994), 1, sym__block_terminator, - STATE(2690), 2, + STATE(3179), 2, sym_comment, sym_include, - [107020] = 6, - ACTIONS(373), 1, + [124204] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(987), 1, + STATE(995), 1, sym__block_terminator, - STATE(2691), 2, + STATE(3180), 2, sym_comment, sym_include, - [107040] = 6, - ACTIONS(373), 1, + [124224] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(986), 1, + STATE(997), 1, sym__block_terminator, - STATE(2692), 2, + STATE(3181), 2, sym_comment, sym_include, - [107060] = 6, - ACTIONS(373), 1, + [124244] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(985), 1, + STATE(998), 1, sym__block_terminator, - STATE(2693), 2, + STATE(3182), 2, sym_comment, sym_include, - [107080] = 6, - ACTIONS(373), 1, + [124264] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(984), 1, + STATE(999), 1, sym__block_terminator, - STATE(2694), 2, + STATE(3183), 2, sym_comment, sym_include, - [107100] = 6, - ACTIONS(373), 1, + [124284] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(983), 1, - sym__block_terminator, - STATE(2695), 2, + ACTIONS(4564), 1, + aux_sym_getter_token1, + ACTIONS(4566), 1, + aux_sym_setter_token1, + STATE(3184), 2, sym_comment, sym_include, - [107120] = 6, - ACTIONS(373), 1, + [124304] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(982), 1, + STATE(1000), 1, sym__block_terminator, - STATE(2696), 2, + STATE(3185), 2, sym_comment, sym_include, - [107140] = 5, - ACTIONS(373), 1, + [124324] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3768), 2, - sym__terminator, - anon_sym_COLON, - STATE(2697), 2, + ACTIONS(4568), 1, + sym_identifier, + STATE(1662), 1, + sym_qualified_name, + STATE(3186), 2, sym_comment, sym_include, - [107158] = 6, - ACTIONS(373), 1, + [124344] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(980), 1, + STATE(1001), 1, sym__block_terminator, - STATE(2698), 2, + STATE(3187), 2, sym_comment, sym_include, - [107178] = 6, - ACTIONS(373), 1, + [124364] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3770), 1, - aux_sym_variable_definition_token5, - ACTIONS(3772), 1, - aux_sym_variable_definition_token6, - STATE(2699), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2116), 1, + sym_query_fields, + STATE(3188), 2, sym_comment, sym_include, - [107198] = 6, - ACTIONS(373), 1, + [124384] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(979), 1, + STATE(1002), 1, sym__block_terminator, - STATE(2700), 2, + STATE(3189), 2, sym_comment, sym_include, - [107218] = 6, - ACTIONS(373), 1, + [124404] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(977), 1, + STATE(1094), 1, sym__block_terminator, - STATE(2701), 2, + STATE(3190), 2, sym_comment, sym_include, - [107238] = 6, - ACTIONS(373), 1, + [124424] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(976), 1, + STATE(1003), 1, sym__block_terminator, - STATE(2702), 2, + STATE(3191), 2, sym_comment, sym_include, - [107258] = 6, - ACTIONS(373), 1, + [124444] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(975), 1, + STATE(1293), 1, sym__block_terminator, - STATE(2703), 2, + STATE(3192), 2, sym_comment, sym_include, - [107278] = 6, - ACTIONS(373), 1, + [124464] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(973), 1, + STATE(1352), 1, sym__block_terminator, - STATE(2704), 2, + STATE(3193), 2, sym_comment, sym_include, - [107298] = 6, - ACTIONS(373), 1, + [124484] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(972), 1, + STATE(1093), 1, sym__block_terminator, - STATE(2705), 2, + STATE(3194), 2, sym_comment, sym_include, - [107318] = 6, - ACTIONS(373), 1, + [124504] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(969), 1, + STATE(1092), 1, sym__block_terminator, - STATE(2706), 2, + STATE(3195), 2, sym_comment, sym_include, - [107338] = 6, - ACTIONS(373), 1, + [124524] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(968), 1, + STATE(1404), 1, sym__block_terminator, - STATE(2707), 2, + STATE(3196), 2, sym_comment, sym_include, - [107358] = 6, - ACTIONS(373), 1, + [124544] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(967), 1, - sym__block_terminator, - STATE(2708), 2, + ACTIONS(4570), 1, + sym_identifier, + STATE(1876), 1, + sym_qualified_name, + STATE(3197), 2, sym_comment, sym_include, - [107378] = 6, - ACTIONS(373), 1, + [124564] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3774), 1, - aux_sym_buffer_definition_token2, - ACTIONS(3776), 1, - aux_sym_repeat_statement_token1, - STATE(2709), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1091), 1, + sym__block_terminator, + STATE(3198), 2, sym_comment, sym_include, - [107398] = 6, - ACTIONS(373), 1, + [124584] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1826), 1, - sym_query_fields, - STATE(2710), 2, + ACTIONS(4572), 1, + sym_identifier, + STATE(2493), 1, + sym_qualified_name, + STATE(3199), 2, sym_comment, sym_include, - [107418] = 6, - ACTIONS(373), 1, + [124604] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, + ACTIONS(4444), 1, anon_sym_LPAREN, - STATE(1886), 1, + STATE(2119), 1, sym_query_fields, - STATE(2711), 2, + STATE(3200), 2, sym_comment, sym_include, - [107438] = 6, - ACTIONS(373), 1, + [124624] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(966), 1, + STATE(1090), 1, sym__block_terminator, - STATE(2712), 2, + STATE(3201), 2, sym_comment, sym_include, - [107458] = 6, - ACTIONS(373), 1, + [124644] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(964), 1, + STATE(1089), 1, sym__block_terminator, - STATE(2713), 2, + STATE(3202), 2, sym_comment, sym_include, - [107478] = 6, - ACTIONS(373), 1, + [124664] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(963), 1, + STATE(1004), 1, sym__block_terminator, - STATE(2714), 2, + STATE(3203), 2, sym_comment, sym_include, - [107498] = 6, - ACTIONS(373), 1, + [124684] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(961), 1, - sym__block_terminator, - STATE(2715), 2, + ACTIONS(4574), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3204), 2, sym_comment, sym_include, - [107518] = 6, - ACTIONS(373), 1, + [124702] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(954), 1, - sym__block_terminator, - STATE(2716), 2, + ACTIONS(4576), 1, + aux_sym_input_close_statement_token2, + ACTIONS(4578), 1, + aux_sym_output_stream_statement_token1, + STATE(3205), 2, sym_comment, sym_include, - [107538] = 6, - ACTIONS(373), 1, + [124722] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(952), 1, + STATE(1088), 1, sym__block_terminator, - STATE(2717), 2, + STATE(3206), 2, sym_comment, sym_include, - [107558] = 6, - ACTIONS(373), 1, + [124742] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(949), 1, - sym__block_terminator, - STATE(2718), 2, + ACTIONS(4580), 1, + sym_identifier, + STATE(287), 1, + sym_qualified_name, + STATE(3207), 2, sym_comment, sym_include, - [107578] = 6, - ACTIONS(373), 1, + [124762] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(948), 1, + STATE(1005), 1, sym__block_terminator, - STATE(2719), 2, + STATE(3208), 2, sym_comment, sym_include, - [107598] = 6, + [124782] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3778), 1, - sym_identifier, - ACTIONS(3780), 1, - anon_sym_COMMA, - STATE(2720), 2, + ACTIONS(2046), 1, + anon_sym_RPAREN, + ACTIONS(4582), 1, + anon_sym_, + STATE(3209), 2, + sym_comment, + sym_include, + [124802] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4578), 1, + aux_sym_output_stream_statement_token1, + ACTIONS(4584), 1, + aux_sym_input_close_statement_token2, + STATE(3210), 2, sym_comment, sym_include, - [107618] = 6, - ACTIONS(373), 1, + [124822] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(945), 1, + STATE(1087), 1, sym__block_terminator, - STATE(2721), 2, + STATE(3211), 2, + sym_comment, + sym_include, + [124842] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2077), 1, + sym_query_fields, + STATE(3212), 2, sym_comment, sym_include, - [107638] = 6, - ACTIONS(373), 1, + [124862] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(944), 1, + STATE(1086), 1, sym__block_terminator, - STATE(2722), 2, + STATE(3213), 2, + sym_comment, + sym_include, + [124882] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4586), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(3214), 2, sym_comment, sym_include, - [107658] = 6, + [124900] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3782), 1, + ACTIONS(4588), 1, sym_identifier, - ACTIONS(3784), 1, - anon_sym_COMMA, - STATE(2723), 2, + STATE(565), 1, + sym_qualified_name, + STATE(3215), 2, sym_comment, sym_include, - [107678] = 6, - ACTIONS(373), 1, + [124920] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(941), 1, - sym__block_terminator, - STATE(2724), 2, + ACTIONS(4590), 1, + sym__terminator, + ACTIONS(4592), 1, + aux_sym_class_statement_token1, + STATE(3216), 2, sym_comment, sym_include, - [107698] = 6, - ACTIONS(373), 1, + [124940] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(940), 1, + STATE(1085), 1, sym__block_terminator, - STATE(2725), 2, + STATE(3217), 2, sym_comment, sym_include, - [107718] = 6, - ACTIONS(373), 1, + [124960] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(936), 1, + STATE(1006), 1, sym__block_terminator, - STATE(2726), 2, + STATE(3218), 2, sym_comment, sym_include, - [107738] = 6, - ACTIONS(3), 1, + [124980] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3786), 1, - sym_identifier, - STATE(796), 1, - sym_qualified_name, - STATE(2727), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1083), 1, + sym__block_terminator, + STATE(3219), 2, sym_comment, sym_include, - [107758] = 6, - ACTIONS(373), 1, + [125000] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1905), 1, - sym_query_fields, - STATE(2728), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1152), 1, + sym__block_terminator, + STATE(3220), 2, sym_comment, sym_include, - [107778] = 6, - ACTIONS(3), 1, + [125020] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3788), 1, - sym_identifier, - ACTIONS(3790), 1, + ACTIONS(3982), 2, + anon_sym_RPAREN, anon_sym_COMMA, - STATE(2729), 2, + STATE(3221), 2, sym_comment, sym_include, - [107798] = 6, - ACTIONS(373), 1, + [125038] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(934), 1, + STATE(1082), 1, sym__block_terminator, - STATE(2730), 2, + STATE(3222), 2, sym_comment, sym_include, - [107818] = 6, - ACTIONS(373), 1, + [125058] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3724), 1, - aux_sym__block_terminator_token1, - STATE(932), 1, - sym__block_terminator, - STATE(2731), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2169), 1, + sym_query_fields, + STATE(3223), 2, sym_comment, sym_include, - [107838] = 6, - ACTIONS(373), 1, + [125078] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1093), 1, + STATE(1081), 1, sym__block_terminator, - STATE(2732), 2, + STATE(3224), 2, sym_comment, sym_include, - [107858] = 6, - ACTIONS(373), 1, + [125098] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1072), 1, + STATE(1080), 1, sym__block_terminator, - STATE(2733), 2, + STATE(3225), 2, sym_comment, sym_include, - [107878] = 6, - ACTIONS(373), 1, + [125118] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3668), 1, - aux_sym_scope_tuning_token1, - STATE(3122), 1, - sym_new_expression, - STATE(2734), 2, + ACTIONS(4594), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3226), 2, sym_comment, sym_include, - [107898] = 6, - ACTIONS(3), 1, + [125136] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3792), 1, - sym_identifier, - STATE(783), 1, - sym_function_call, - STATE(2735), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1079), 1, + sym__block_terminator, + STATE(3227), 2, sym_comment, sym_include, - [107918] = 6, - ACTIONS(373), 1, + [125156] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(1056), 1, + STATE(1007), 1, sym__block_terminator, - STATE(2736), 2, + STATE(3228), 2, sym_comment, sym_include, - [107938] = 6, - ACTIONS(373), 1, + [125176] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1042), 1, - sym__block_terminator, - STATE(2737), 2, + ACTIONS(4596), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(3229), 2, sym_comment, sym_include, - [107958] = 6, - ACTIONS(373), 1, + [125194] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3794), 1, - anon_sym_DOT, - ACTIONS(3796), 1, - aux_sym__procedure_terminator_token1, - STATE(2738), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1078), 1, + sym__block_terminator, + STATE(3230), 2, sym_comment, sym_include, - [107978] = 6, - ACTIONS(373), 1, + [125214] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(383), 1, - sym__namedot, - STATE(275), 1, - aux_sym_qualified_name_repeat1, - STATE(2739), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1247), 1, + sym__block_terminator, + STATE(3231), 2, sym_comment, sym_include, - [107998] = 6, - ACTIONS(373), 1, + [125234] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1928), 1, - sym_query_fields, - STATE(2740), 2, + ACTIONS(4598), 1, + aux_sym_primitive_type_token1, + ACTIONS(4600), 1, + aux_sym_event_definition_token2, + STATE(3232), 2, sym_comment, sym_include, - [108018] = 6, - ACTIONS(373), 1, + [125254] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(920), 1, + STATE(1077), 1, sym__block_terminator, - STATE(2741), 2, + STATE(3233), 2, sym_comment, sym_include, - [108038] = 6, - ACTIONS(373), 1, + [125274] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(919), 1, + STATE(1398), 1, sym__block_terminator, - STATE(2742), 2, + STATE(3234), 2, sym_comment, sym_include, - [108058] = 6, - ACTIONS(373), 1, + [125294] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(917), 1, + STATE(1008), 1, sym__block_terminator, - STATE(2743), 2, + STATE(3235), 2, sym_comment, sym_include, - [108078] = 6, - ACTIONS(373), 1, + [125314] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(914), 1, + STATE(1076), 1, sym__block_terminator, - STATE(2744), 2, + STATE(3236), 2, sym_comment, sym_include, - [108098] = 6, - ACTIONS(373), 1, + [125334] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(913), 1, + STATE(1075), 1, sym__block_terminator, - STATE(2745), 2, + STATE(3237), 2, sym_comment, sym_include, - [108118] = 6, - ACTIONS(373), 1, + [125354] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(912), 1, + STATE(1285), 1, sym__block_terminator, - STATE(2746), 2, + STATE(3238), 2, sym_comment, sym_include, - [108138] = 6, - ACTIONS(373), 1, + [125374] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(911), 1, - sym__block_terminator, - STATE(2747), 2, + ACTIONS(4602), 1, + sym_identifier, + ACTIONS(4604), 1, + sym__integer_literal, + STATE(3239), 2, sym_comment, sym_include, - [108158] = 6, - ACTIONS(373), 1, + [125394] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(910), 1, + STATE(1127), 1, sym__block_terminator, - STATE(2748), 2, + STATE(3240), 2, sym_comment, sym_include, - [108178] = 6, - ACTIONS(373), 1, + [125414] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(909), 1, - sym__block_terminator, - STATE(2749), 2, + ACTIONS(4606), 1, + sym_identifier, + ACTIONS(4608), 1, + sym__terminator, + STATE(3241), 2, sym_comment, sym_include, - [108198] = 6, - ACTIONS(373), 1, + [125434] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(908), 1, - sym__block_terminator, - STATE(2750), 2, + ACTIONS(4610), 1, + aux_sym_variable_definition_token5, + ACTIONS(4612), 1, + aux_sym_variable_definition_token6, + STATE(3242), 2, sym_comment, sym_include, - [108218] = 6, - ACTIONS(373), 1, + [125454] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(907), 1, - sym__block_terminator, - STATE(2751), 2, + ACTIONS(4614), 1, + sym__terminator, + ACTIONS(4616), 1, + aux_sym_interface_statement_token1, + STATE(3243), 2, + sym_comment, + sym_include, + [125474] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(71), 2, + sym__namedot, + sym_identifier, + STATE(3244), 2, sym_comment, sym_include, - [108238] = 6, - ACTIONS(373), 1, + [125492] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(906), 1, + STATE(1009), 1, sym__block_terminator, - STATE(2752), 2, + STATE(3245), 2, sym_comment, sym_include, - [108258] = 6, - ACTIONS(373), 1, + [125512] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4618), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3246), 2, + sym_comment, + sym_include, + [125530] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(905), 1, + STATE(1010), 1, sym__block_terminator, - STATE(2753), 2, + STATE(3247), 2, sym_comment, sym_include, - [108278] = 6, - ACTIONS(373), 1, + [125550] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(904), 1, + STATE(1246), 1, sym__block_terminator, - STATE(2754), 2, + STATE(3248), 2, sym_comment, sym_include, - [108298] = 6, - ACTIONS(373), 1, + [125570] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(903), 1, + STATE(1073), 1, sym__block_terminator, - STATE(2755), 2, + STATE(3249), 2, sym_comment, sym_include, - [108318] = 6, - ACTIONS(373), 1, + [125590] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(902), 1, + STATE(1378), 1, sym__block_terminator, - STATE(2756), 2, + STATE(3250), 2, sym_comment, sym_include, - [108338] = 6, - ACTIONS(373), 1, + [125610] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(901), 1, + STATE(1072), 1, sym__block_terminator, - STATE(2757), 2, + STATE(3251), 2, + sym_comment, + sym_include, + [125630] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2212), 1, + sym_query_fields, + STATE(3252), 2, sym_comment, sym_include, - [108358] = 6, - ACTIONS(373), 1, + [125650] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(900), 1, + STATE(1282), 1, sym__block_terminator, - STATE(2758), 2, + STATE(3253), 2, sym_comment, sym_include, - [108378] = 6, - ACTIONS(373), 1, + [125670] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(898), 1, + STATE(1289), 1, sym__block_terminator, - STATE(2759), 2, + STATE(3254), 2, sym_comment, sym_include, - [108398] = 6, - ACTIONS(373), 1, + [125690] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(897), 1, + STATE(1394), 1, sym__block_terminator, - STATE(2760), 2, + STATE(3255), 2, sym_comment, sym_include, - [108418] = 6, - ACTIONS(373), 1, + [125710] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(896), 1, + STATE(1011), 1, sym__block_terminator, - STATE(2761), 2, + STATE(3256), 2, sym_comment, sym_include, - [108438] = 6, - ACTIONS(373), 1, + [125730] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(891), 1, + STATE(1104), 1, sym__block_terminator, - STATE(2762), 2, + STATE(3257), 2, sym_comment, sym_include, - [108458] = 6, - ACTIONS(373), 1, + [125750] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(890), 1, + STATE(1134), 1, sym__block_terminator, - STATE(2763), 2, + STATE(3258), 2, + sym_comment, + sym_include, + [125770] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(4620), 1, + sym_identifier, + STATE(292), 1, + sym_qualified_name, + STATE(3259), 2, + sym_comment, + sym_include, + [125790] = 6, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(4622), 1, + sym_identifier, + STATE(2148), 1, + sym_qualified_name, + STATE(3260), 2, sym_comment, sym_include, - [108478] = 6, - ACTIONS(373), 1, + [125810] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(888), 1, + STATE(1071), 1, sym__block_terminator, - STATE(2764), 2, + STATE(3261), 2, sym_comment, sym_include, - [108498] = 6, - ACTIONS(373), 1, + [125830] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(887), 1, + STATE(1070), 1, sym__block_terminator, - STATE(2765), 2, + STATE(3262), 2, sym_comment, sym_include, - [108518] = 6, - ACTIONS(373), 1, + [125850] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(884), 1, + STATE(1013), 1, sym__block_terminator, - STATE(2766), 2, + STATE(3263), 2, sym_comment, sym_include, - [108538] = 6, - ACTIONS(373), 1, + [125870] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(883), 1, + STATE(1245), 1, sym__block_terminator, - STATE(2767), 2, + STATE(3264), 2, sym_comment, sym_include, - [108558] = 6, - ACTIONS(373), 1, + [125890] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(882), 1, - sym__block_terminator, - STATE(2768), 2, + ACTIONS(3473), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3265), 2, sym_comment, sym_include, - [108578] = 6, - ACTIONS(373), 1, + [125908] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(881), 1, + STATE(1014), 1, sym__block_terminator, - STATE(2769), 2, + STATE(3266), 2, sym_comment, sym_include, - [108598] = 6, - ACTIONS(373), 1, + [125928] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(879), 1, + STATE(1015), 1, sym__block_terminator, - STATE(2770), 2, + STATE(3267), 2, sym_comment, sym_include, - [108618] = 6, - ACTIONS(373), 1, + [125948] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3800), 1, - sym__terminator, - ACTIONS(3802), 1, - aux_sym_class_statement_token1, - STATE(2771), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1357), 1, + sym__block_terminator, + STATE(3268), 2, sym_comment, sym_include, - [108638] = 6, - ACTIONS(373), 1, + [125968] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(851), 1, + STATE(1069), 1, sym__block_terminator, - STATE(2772), 2, + STATE(3269), 2, sym_comment, sym_include, - [108658] = 5, - ACTIONS(373), 1, + [125988] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3804), 2, + ACTIONS(4624), 2, aux_sym_on_error_phrase_token2, aux_sym_on_error_phrase_token7, - STATE(2773), 2, + STATE(3270), 2, sym_comment, sym_include, - [108676] = 6, - ACTIONS(373), 1, + [126006] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(852), 1, - sym__block_terminator, - STATE(2774), 2, + ACTIONS(2076), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3271), 2, sym_comment, sym_include, - [108696] = 6, - ACTIONS(3), 1, + [126024] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3806), 1, - sym_identifier, - ACTIONS(3808), 1, - sym__integer_literal, - STATE(2775), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1068), 1, + sym__block_terminator, + STATE(3272), 2, sym_comment, sym_include, - [108716] = 6, - ACTIONS(3), 1, + [126044] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3810), 1, - sym_identifier, - ACTIONS(3812), 1, - sym__terminator, - STATE(2776), 2, + ACTIONS(4012), 1, + sym__namedot, + STATE(2690), 1, + aux_sym_qualified_name_repeat1, + STATE(3273), 2, sym_comment, sym_include, - [108736] = 6, - ACTIONS(373), 1, + [126064] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(856), 1, - sym__block_terminator, - STATE(2777), 2, + ACTIONS(4626), 1, + sym__terminator, + ACTIONS(4628), 1, + aux_sym_interface_statement_token1, + STATE(3274), 2, sym_comment, sym_include, - [108756] = 6, - ACTIONS(373), 1, + [126084] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3668), 1, - aux_sym_scope_tuning_token1, - STATE(3079), 1, - sym_new_expression, - STATE(2778), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1325), 1, + sym__block_terminator, + STATE(3275), 2, sym_comment, sym_include, - [108776] = 6, - ACTIONS(373), 1, + [126104] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(858), 1, - sym__block_terminator, - STATE(2779), 2, + ACTIONS(4630), 1, + sym__terminator, + ACTIONS(4632), 1, + aux_sym_class_statement_token1, + STATE(3276), 2, sym_comment, sym_include, - [108796] = 6, - ACTIONS(373), 1, + [126124] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(860), 1, + STATE(1016), 1, sym__block_terminator, - STATE(2780), 2, + STATE(3277), 2, sym_comment, sym_include, - [108816] = 6, - ACTIONS(373), 1, + [126144] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(861), 1, - sym__block_terminator, - STATE(2781), 2, + ACTIONS(4634), 2, + sym__terminator, + anon_sym_COLON, + STATE(3278), 2, sym_comment, sym_include, - [108836] = 6, - ACTIONS(373), 1, + [126162] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(864), 1, + STATE(1166), 1, sym__block_terminator, - STATE(2782), 2, + STATE(3279), 2, sym_comment, sym_include, - [108856] = 6, - ACTIONS(373), 1, + [126182] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3794), 1, - anon_sym_DOT, - ACTIONS(3814), 1, - aux_sym__case_terminator_token1, - STATE(2783), 2, + ACTIONS(4636), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3280), 2, sym_comment, sym_include, - [108876] = 6, - ACTIONS(373), 1, + [126200] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(865), 1, - sym__block_terminator, - STATE(2784), 2, + ACTIONS(3874), 1, + aux_sym_on_stop_phrase_token1, + ACTIONS(4161), 1, + aux_sym_on_quit_phrase_token1, + STATE(3281), 2, sym_comment, sym_include, - [108896] = 6, + [126220] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3816), 1, + ACTIONS(4638), 1, sym_identifier, - STATE(3075), 1, - sym_qualified_name, - STATE(2785), 2, + ACTIONS(4640), 1, + sym__terminator, + STATE(3282), 2, sym_comment, sym_include, - [108916] = 6, - ACTIONS(373), 1, + [126240] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3818), 1, - sym__terminator, - ACTIONS(3820), 1, - aux_sym_finally_statement_token1, - STATE(2786), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1066), 1, + sym__block_terminator, + STATE(3283), 2, sym_comment, sym_include, - [108936] = 6, - ACTIONS(373), 1, + [126260] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(867), 1, - sym__block_terminator, - STATE(2787), 2, + ACTIONS(4642), 1, + sym_identifier, + STATE(2166), 1, + sym_qualified_name, + STATE(3284), 2, sym_comment, sym_include, - [108956] = 6, - ACTIONS(373), 1, + [126280] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(868), 1, + STATE(1065), 1, sym__block_terminator, - STATE(2788), 2, + STATE(3285), 2, sym_comment, sym_include, - [108976] = 6, - ACTIONS(373), 1, + [126300] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(872), 1, + STATE(1107), 1, sym__block_terminator, - STATE(2789), 2, + STATE(3286), 2, sym_comment, sym_include, - [108996] = 6, + [126320] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3822), 1, + ACTIONS(4644), 1, sym_identifier, - STATE(263), 1, + STATE(1485), 1, sym_qualified_name, - STATE(2790), 2, + STATE(3287), 2, sym_comment, sym_include, - [109016] = 6, + [126340] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3824), 1, + ACTIONS(4646), 1, sym_identifier, - STATE(834), 1, + STATE(1688), 1, sym_qualified_name, - STATE(2791), 2, + STATE(3288), 2, sym_comment, sym_include, - [109036] = 5, - ACTIONS(373), 1, + [126360] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3239), 2, + ACTIONS(4080), 2, anon_sym_RPAREN, anon_sym_COMMA, - STATE(2792), 2, + STATE(3289), 2, sym_comment, sym_include, - [109054] = 6, - ACTIONS(373), 1, + [126378] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(874), 1, + STATE(1295), 1, sym__block_terminator, - STATE(2793), 2, + STATE(3290), 2, sym_comment, sym_include, - [109074] = 6, - ACTIONS(373), 1, + [126398] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3798), 1, - aux_sym__block_terminator_token1, - STATE(876), 1, - sym__block_terminator, - STATE(2794), 2, + ACTIONS(4648), 1, + aux_sym_variable_definition_token5, + ACTIONS(4650), 1, + aux_sym_function_parameter_token2, + STATE(3291), 2, sym_comment, sym_include, - [109094] = 6, + [126418] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3826), 1, + ACTIONS(4652), 1, sym_identifier, - ACTIONS(3828), 1, - aux_sym_input_expression_token2, - STATE(2795), 2, + ACTIONS(4654), 1, + aux_sym_function_parameter_token1, + STATE(3292), 2, + sym_comment, + sym_include, + [126438] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4656), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3293), 2, sym_comment, sym_include, - [109114] = 6, + [126456] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3830), 1, + ACTIONS(4658), 1, sym_identifier, - STATE(3059), 1, - sym_qualified_name, - STATE(2796), 2, + ACTIONS(4660), 1, + anon_sym_RPAREN, + STATE(3294), 2, sym_comment, sym_include, - [109134] = 6, - ACTIONS(373), 1, + [126476] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3832), 1, - aux_sym_variable_definition_token5, - ACTIONS(3834), 1, - aux_sym_variable_definition_token6, - STATE(2797), 2, + ACTIONS(4662), 1, + sym__terminator, + ACTIONS(4664), 1, + aux_sym_finally_statement_token1, + STATE(3295), 2, sym_comment, sym_include, - [109154] = 6, + [126496] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3836), 1, + ACTIONS(4666), 1, sym_identifier, - STATE(612), 1, - sym_function_call, - STATE(2798), 2, + STATE(2917), 1, + sym_qualified_name, + STATE(3296), 2, sym_comment, sym_include, - [109174] = 6, - ACTIONS(3), 1, + [126516] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3838), 1, - sym_identifier, - STATE(1853), 1, - sym_qualified_name, - STATE(2799), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1155), 1, + sym__block_terminator, + STATE(3297), 2, sym_comment, sym_include, - [109194] = 6, + [126536] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3840), 1, + ACTIONS(4668), 2, sym_identifier, - STATE(1395), 1, - sym_qualified_name, - STATE(2800), 2, + aux_sym_function_parameter_token1, + STATE(3298), 2, sym_comment, sym_include, - [109214] = 5, - ACTIONS(373), 1, + [126554] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3301), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2801), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1125), 1, + sym__block_terminator, + STATE(3299), 2, sym_comment, sym_include, - [109232] = 6, - ACTIONS(373), 1, + [126574] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1029), 1, - sym__block_terminator, - STATE(2802), 2, + ACTIONS(4670), 2, + anon_sym_RPAREN, + anon_sym_COMMA, + STATE(3300), 2, sym_comment, sym_include, - [109252] = 6, - ACTIONS(373), 1, + [126592] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1068), 1, + STATE(1061), 1, sym__block_terminator, - STATE(2803), 2, + STATE(3301), 2, sym_comment, sym_include, - [109272] = 5, - ACTIONS(373), 1, + [126612] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3842), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2804), 2, + ACTIONS(4672), 1, + sym_identifier, + STATE(2403), 1, + sym_qualified_name, + STATE(3302), 2, sym_comment, sym_include, - [109290] = 6, - ACTIONS(373), 1, + [126632] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1341), 1, + STATE(1060), 1, sym__block_terminator, - STATE(2805), 2, + STATE(3303), 2, sym_comment, sym_include, - [109310] = 6, - ACTIONS(373), 1, + [126652] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1208), 1, + STATE(1059), 1, sym__block_terminator, - STATE(2806), 2, + STATE(3304), 2, sym_comment, sym_include, - [109330] = 6, - ACTIONS(373), 1, + [126672] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1209), 1, - sym__block_terminator, - STATE(2807), 2, + ACTIONS(4444), 1, + anon_sym_LPAREN, + STATE(2115), 1, + sym_query_fields, + STATE(3305), 2, sym_comment, sym_include, - [109350] = 6, - ACTIONS(373), 1, + [126692] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1043), 1, + STATE(1058), 1, sym__block_terminator, - STATE(2808), 2, + STATE(3306), 2, sym_comment, sym_include, - [109370] = 6, - ACTIONS(373), 1, + [126712] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1214), 1, - sym__block_terminator, - STATE(2809), 2, + ACTIONS(4674), 2, + sym__terminator, + anon_sym_COLON, + STATE(3307), 2, sym_comment, sym_include, - [109390] = 6, - ACTIONS(373), 1, + [126730] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1215), 1, + STATE(1116), 1, sym__block_terminator, - STATE(2810), 2, + STATE(3308), 2, sym_comment, sym_include, - [109410] = 6, - ACTIONS(373), 1, + [126750] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1216), 1, + STATE(1257), 1, sym__block_terminator, - STATE(2811), 2, + STATE(3309), 2, sym_comment, sym_include, - [109430] = 6, - ACTIONS(373), 1, + [126770] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1217), 1, - sym__block_terminator, - STATE(2812), 2, + ACTIONS(4676), 1, + sym_identifier, + STATE(2098), 1, + sym_qualified_name, + STATE(3310), 2, sym_comment, sym_include, - [109450] = 6, - ACTIONS(373), 1, + [126790] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1224), 1, - sym__block_terminator, - STATE(2813), 2, + ACTIONS(4678), 1, + sym__terminator, + ACTIONS(4680), 1, + aux_sym_finally_statement_token1, + STATE(3311), 2, sym_comment, sym_include, - [109470] = 6, - ACTIONS(373), 1, + [126810] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1225), 1, + STATE(1055), 1, sym__block_terminator, - STATE(2814), 2, + STATE(3312), 2, sym_comment, sym_include, - [109490] = 6, - ACTIONS(373), 1, + [126830] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1231), 1, + STATE(1054), 1, sym__block_terminator, - STATE(2815), 2, + STATE(3313), 2, sym_comment, sym_include, - [109510] = 6, - ACTIONS(373), 1, + [126850] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1238), 1, + STATE(1106), 1, sym__block_terminator, - STATE(2816), 2, + STATE(3314), 2, sym_comment, sym_include, - [109530] = 6, - ACTIONS(373), 1, + [126870] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1240), 1, + STATE(1028), 1, sym__block_terminator, - STATE(2817), 2, + STATE(3315), 2, sym_comment, sym_include, - [109550] = 6, - ACTIONS(373), 1, + [126890] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1250), 1, - sym__block_terminator, - STATE(2818), 2, + ACTIONS(4682), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3316), 2, sym_comment, sym_include, - [109570] = 6, - ACTIONS(373), 1, + [126908] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1060), 1, - sym__block_terminator, - STATE(2819), 2, + ACTIONS(4684), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3317), 2, sym_comment, sym_include, - [109590] = 6, - ACTIONS(373), 1, + [126926] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1064), 1, - sym__block_terminator, - STATE(2820), 2, + ACTIONS(4686), 2, + sym__terminator, + anon_sym_COLON, + STATE(3318), 2, sym_comment, sym_include, - [109610] = 6, - ACTIONS(373), 1, + [126944] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1066), 1, - sym__block_terminator, - STATE(2821), 2, + ACTIONS(4688), 1, + sym_identifier, + STATE(759), 1, + sym_function_call, + STATE(3319), 2, sym_comment, sym_include, - [109630] = 6, - ACTIONS(373), 1, + [126964] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1289), 1, + STATE(1053), 1, sym__block_terminator, - STATE(2822), 2, + STATE(3320), 2, sym_comment, sym_include, - [109650] = 6, - ACTIONS(373), 1, + [126984] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1323), 1, + STATE(1117), 1, sym__block_terminator, - STATE(2823), 2, + STATE(3321), 2, sym_comment, sym_include, - [109670] = 6, - ACTIONS(373), 1, + [127004] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1325), 1, + STATE(1341), 1, sym__block_terminator, - STATE(2824), 2, - sym_comment, - sym_include, - [109690] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3846), 1, - sym__terminator, - ACTIONS(3848), 1, - aux_sym_catch_statement_token1, - STATE(2825), 2, + STATE(3322), 2, sym_comment, sym_include, - [109710] = 6, - ACTIONS(373), 1, + [127024] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3850), 1, - sym__terminator, - ACTIONS(3852), 1, - aux_sym_class_statement_token1, - STATE(2826), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1370), 1, + sym__block_terminator, + STATE(3323), 2, sym_comment, sym_include, - [109730] = 6, - ACTIONS(373), 1, + [127044] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3854), 1, + ACTIONS(4690), 1, sym__terminator, - ACTIONS(3856), 1, + ACTIONS(4692), 1, aux_sym_class_statement_token1, - STATE(2827), 2, + STATE(3324), 2, sym_comment, sym_include, - [109750] = 5, - ACTIONS(373), 1, + [127064] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3858), 2, - sym__terminator, + ACTIONS(4694), 2, + anon_sym_COMMA, anon_sym_COLON, - STATE(2828), 2, - sym_comment, - sym_include, - [109768] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3860), 1, - sym__terminator, - ACTIONS(3862), 1, - aux_sym_class_statement_token1, - STATE(2829), 2, + STATE(3325), 2, sym_comment, sym_include, - [109788] = 6, - ACTIONS(373), 1, + [127082] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1394), 1, - sym__block_terminator, - STATE(2830), 2, + ACTIONS(4696), 1, + sym_identifier, + STATE(794), 1, + sym_qualified_name, + STATE(3326), 2, sym_comment, sym_include, - [109808] = 5, - ACTIONS(373), 1, + [127102] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3864), 2, - aux_sym_input_expression_token2, - aux_sym_do_while_statement_token1, - STATE(2831), 2, + ACTIONS(4698), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3327), 2, sym_comment, sym_include, - [109826] = 6, - ACTIONS(373), 1, + [127120] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1110), 1, + STATE(1338), 1, sym__block_terminator, - STATE(2832), 2, + STATE(3328), 2, sym_comment, sym_include, - [109846] = 6, - ACTIONS(373), 1, + [127140] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1390), 1, + STATE(1337), 1, sym__block_terminator, - STATE(2833), 2, + STATE(3329), 2, sym_comment, sym_include, - [109866] = 6, - ACTIONS(373), 1, + [127160] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4434), 1, aux_sym__block_terminator_token1, - STATE(1389), 1, + STATE(990), 1, sym__block_terminator, - STATE(2834), 2, + STATE(3330), 2, sym_comment, sym_include, - [109886] = 6, - ACTIONS(373), 1, + [127180] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1388), 1, - sym__block_terminator, - STATE(2835), 2, + ACTIONS(4700), 1, + sym_identifier, + STATE(306), 1, + sym_qualified_name, + STATE(3331), 2, sym_comment, sym_include, - [109906] = 6, - ACTIONS(373), 1, + [127200] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1386), 1, - sym__block_terminator, - STATE(2836), 2, + ACTIONS(4702), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3332), 2, sym_comment, sym_include, - [109926] = 6, - ACTIONS(373), 1, + [127218] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1385), 1, + STATE(1373), 1, sym__block_terminator, - STATE(2837), 2, + STATE(3333), 2, sym_comment, sym_include, - [109946] = 6, - ACTIONS(373), 1, + [127238] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1384), 1, + STATE(1048), 1, sym__block_terminator, - STATE(2838), 2, + STATE(3334), 2, sym_comment, sym_include, - [109966] = 6, - ACTIONS(373), 1, + [127258] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3866), 1, + ACTIONS(4704), 1, sym__terminator, - ACTIONS(3868), 1, - aux_sym_catch_statement_token1, - STATE(2839), 2, + ACTIONS(4706), 1, + aux_sym_finally_statement_token1, + STATE(3335), 2, sym_comment, sym_include, - [109986] = 6, - ACTIONS(373), 1, + [127278] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3870), 1, + ACTIONS(4708), 1, sym__terminator, - ACTIONS(3872), 1, - aux_sym_catch_statement_token1, - STATE(2840), 2, - sym_comment, - sym_include, - [110006] = 6, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1121), 1, - sym__block_terminator, - STATE(2841), 2, + ACTIONS(4710), 1, + aux_sym_interface_statement_token1, + STATE(3336), 2, sym_comment, sym_include, - [110026] = 6, + [127298] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3874), 1, + ACTIONS(4712), 1, sym_identifier, - ACTIONS(3876), 1, - aux_sym_input_expression_token2, - STATE(2842), 2, + STATE(1649), 1, + sym_qualified_name, + STATE(3337), 2, sym_comment, sym_include, - [110046] = 6, + [127318] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3878), 1, + ACTIONS(4714), 1, sym_identifier, - STATE(1624), 1, + STATE(3601), 1, sym_qualified_name, - STATE(2843), 2, + STATE(3338), 2, sym_comment, sym_include, - [110066] = 5, - ACTIONS(373), 1, + [127338] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3880), 2, - sym__terminator, - anon_sym_COLON, - STATE(2844), 2, + ACTIONS(4716), 1, + aux_sym_variable_definition_token5, + ACTIONS(4718), 1, + aux_sym_function_parameter_token2, + STATE(3339), 2, sym_comment, sym_include, - [110084] = 6, - ACTIONS(373), 1, + [127358] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1372), 1, + STATE(1046), 1, sym__block_terminator, - STATE(2845), 2, + STATE(3340), 2, sym_comment, sym_include, - [110104] = 6, - ACTIONS(373), 1, + [127378] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1371), 1, + STATE(1045), 1, sym__block_terminator, - STATE(2846), 2, + STATE(3341), 2, sym_comment, sym_include, - [110124] = 6, - ACTIONS(373), 1, + [127398] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1901), 1, - sym_query_fields, - STATE(2847), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1336), 1, + sym__block_terminator, + STATE(3342), 2, sym_comment, sym_include, - [110144] = 6, + [127418] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3882), 1, + ACTIONS(4720), 1, sym_identifier, - STATE(1876), 1, - sym_qualified_name, - STATE(2848), 2, + ACTIONS(4722), 1, + sym__integer_literal, + STATE(3343), 2, sym_comment, sym_include, - [110164] = 6, - ACTIONS(373), 1, + [127438] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1361), 1, + STATE(1043), 1, sym__block_terminator, - STATE(2849), 2, + STATE(3344), 2, sym_comment, sym_include, - [110184] = 6, - ACTIONS(373), 1, + [127458] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1360), 1, + STATE(932), 1, sym__block_terminator, - STATE(2850), 2, + STATE(3345), 2, sym_comment, sym_include, - [110204] = 6, - ACTIONS(373), 1, + [127478] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4724), 1, + anon_sym_COMMA, + ACTIONS(4726), 1, + aux_sym_on_error_phrase_token3, + STATE(3346), 2, + sym_comment, + sym_include, + [127498] = 6, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1357), 1, + STATE(1040), 1, sym__block_terminator, - STATE(2851), 2, + STATE(3347), 2, sym_comment, sym_include, - [110224] = 6, - ACTIONS(373), 1, + [127518] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1356), 1, + STATE(1312), 1, sym__block_terminator, - STATE(2852), 2, + STATE(3348), 2, sym_comment, sym_include, - [110244] = 6, - ACTIONS(3), 1, + [127538] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3884), 1, - sym_identifier, - STATE(3016), 1, - sym_qualified_name, - STATE(2853), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1039), 1, + sym__block_terminator, + STATE(3349), 2, sym_comment, sym_include, - [110264] = 6, - ACTIONS(373), 1, + [127558] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3886), 1, - sym__terminator, - ACTIONS(3888), 1, - aux_sym_catch_statement_token1, - STATE(2854), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1313), 1, + sym__block_terminator, + STATE(3350), 2, sym_comment, sym_include, - [110284] = 6, - ACTIONS(373), 1, + [127578] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3890), 1, - sym__terminator, - ACTIONS(3892), 1, - aux_sym_class_statement_token1, - STATE(2855), 2, + ACTIONS(2116), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3351), 2, sym_comment, sym_include, - [110304] = 6, + [127596] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3894), 1, + ACTIONS(4728), 1, sym_identifier, - STATE(268), 1, - sym_qualified_name, - STATE(2856), 2, + ACTIONS(4730), 1, + aux_sym_input_expression_token2, + STATE(3352), 2, sym_comment, sym_include, - [110324] = 6, - ACTIONS(373), 1, + [127616] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3896), 1, - sym__terminator, - ACTIONS(3898), 1, - aux_sym_class_statement_token1, - STATE(2857), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1030), 1, + sym__block_terminator, + STATE(3353), 2, sym_comment, sym_include, - [110344] = 6, - ACTIONS(373), 1, + [127636] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1144), 1, + STATE(1340), 1, sym__block_terminator, - STATE(2858), 2, + STATE(3354), 2, sym_comment, sym_include, - [110364] = 5, - ACTIONS(373), 1, + [127656] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3900), 2, + ACTIONS(4732), 2, aux_sym_on_error_phrase_token2, aux_sym_on_error_phrase_token7, - STATE(2859), 2, + STATE(3355), 2, sym_comment, sym_include, - [110382] = 6, - ACTIONS(373), 1, + [127674] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1345), 1, + STATE(1385), 1, sym__block_terminator, - STATE(2860), 2, + STATE(3356), 2, sym_comment, sym_include, - [110402] = 6, - ACTIONS(373), 1, + [127694] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1344), 1, + STATE(1123), 1, sym__block_terminator, - STATE(2861), 2, + STATE(3357), 2, sym_comment, sym_include, - [110422] = 6, - ACTIONS(373), 1, + [127714] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1343), 1, + STATE(1315), 1, sym__block_terminator, - STATE(2862), 2, + STATE(3358), 2, sym_comment, sym_include, - [110442] = 5, - ACTIONS(373), 1, + [127734] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3902), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2863), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1381), 1, + sym__block_terminator, + STATE(3359), 2, sym_comment, sym_include, - [110460] = 6, - ACTIONS(373), 1, + [127754] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1340), 1, - sym__block_terminator, - STATE(2864), 2, + ACTIONS(4734), 2, + anon_sym_COMMA, + anon_sym_COLON, + STATE(3360), 2, sym_comment, sym_include, - [110480] = 6, - ACTIONS(373), 1, + [127772] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4236), 1, aux_sym__block_terminator_token1, - STATE(1337), 1, + STATE(1320), 1, sym__block_terminator, - STATE(2865), 2, + STATE(3361), 2, sym_comment, sym_include, - [110500] = 5, - ACTIONS(373), 1, + [127792] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3904), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2866), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1330), 1, + sym__block_terminator, + STATE(3362), 2, sym_comment, sym_include, - [110518] = 6, - ACTIONS(373), 1, + [127812] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4220), 1, aux_sym__block_terminator_token1, - STATE(1149), 1, + STATE(1316), 1, sym__block_terminator, - STATE(2867), 2, + STATE(3363), 2, sym_comment, sym_include, - [110538] = 6, - ACTIONS(373), 1, + [127832] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1321), 1, + STATE(1037), 1, sym__block_terminator, - STATE(2868), 2, + STATE(3364), 2, sym_comment, sym_include, - [110558] = 6, - ACTIONS(373), 1, + [127852] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1317), 1, - sym__block_terminator, - STATE(2869), 2, + ACTIONS(4736), 1, + sym__terminator, + ACTIONS(4738), 1, + aux_sym_catch_statement_token1, + STATE(3365), 2, sym_comment, sym_include, - [110578] = 6, - ACTIONS(373), 1, + [127872] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4228), 1, aux_sym__block_terminator_token1, - STATE(1150), 1, + STATE(2836), 1, sym__block_terminator, - STATE(2870), 2, + STATE(3366), 2, sym_comment, sym_include, - [110598] = 6, - ACTIONS(373), 1, + [127892] = 6, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1152), 1, - sym__block_terminator, - STATE(2871), 2, + ACTIONS(4740), 1, + sym_identifier, + STATE(293), 1, + sym_qualified_name, + STATE(3367), 2, sym_comment, sym_include, - [110618] = 6, - ACTIONS(373), 1, + [127912] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4540), 1, aux_sym__block_terminator_token1, - STATE(1003), 1, + STATE(1036), 1, sym__block_terminator, - STATE(2872), 2, + STATE(3368), 2, sym_comment, sym_include, - [110638] = 6, - ACTIONS(373), 1, + [127932] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1154), 1, - sym__block_terminator, - STATE(2873), 2, + ACTIONS(4742), 2, + aux_sym_on_error_phrase_token2, + aux_sym_on_error_phrase_token7, + STATE(3369), 2, sym_comment, sym_include, - [110658] = 6, + [127950] = 6, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3906), 1, + ACTIONS(4744), 1, sym_identifier, - ACTIONS(3908), 1, - sym__integer_literal, - STATE(2874), 2, + ACTIONS(4746), 1, + sym__terminator, + STATE(3370), 2, sym_comment, sym_include, - [110678] = 6, - ACTIONS(373), 1, + [127970] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3910), 1, - sym__terminator, - ACTIONS(3912), 1, - aux_sym_class_statement_token1, - STATE(2875), 2, + ACTIONS(4414), 1, + aux_sym_scope_tuning_token1, + STATE(3647), 1, + sym_new_expression, + STATE(3371), 2, sym_comment, sym_include, - [110698] = 6, - ACTIONS(373), 1, + [127990] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3914), 1, - sym__terminator, - ACTIONS(3916), 1, - aux_sym_class_statement_token1, - STATE(2876), 2, + ACTIONS(4220), 1, + aux_sym__block_terminator_token1, + STATE(1321), 1, + sym__block_terminator, + STATE(3372), 2, sym_comment, sym_include, - [110718] = 6, - ACTIONS(373), 1, + [128010] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3918), 1, - sym__terminator, - ACTIONS(3920), 1, - aux_sym_class_statement_token1, - STATE(2877), 2, + ACTIONS(4540), 1, + aux_sym__block_terminator_token1, + STATE(1032), 1, + sym__block_terminator, + STATE(3373), 2, sym_comment, sym_include, - [110738] = 5, - ACTIONS(373), 1, + [128030] = 6, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3922), 2, - sym__terminator, - anon_sym_COLON, - STATE(2878), 2, + ACTIONS(4236), 1, + aux_sym__block_terminator_token1, + STATE(1356), 1, + sym__block_terminator, + STATE(3374), 2, sym_comment, sym_include, - [110756] = 6, - ACTIONS(373), 1, + [128050] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3924), 1, + ACTIONS(4748), 1, sym__terminator, - ACTIONS(3926), 1, - aux_sym_class_statement_token1, - STATE(2879), 2, + STATE(3375), 2, sym_comment, sym_include, - [110776] = 6, - ACTIONS(373), 1, + [128067] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1301), 1, - sym__block_terminator, - STATE(2880), 2, + ACTIONS(3422), 1, + anon_sym_COLON, + STATE(3376), 2, sym_comment, sym_include, - [110796] = 6, - ACTIONS(373), 1, + [128084] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1299), 1, - sym__block_terminator, - STATE(2881), 2, + ACTIONS(4750), 1, + anon_sym_RPAREN, + STATE(3377), 2, sym_comment, sym_include, - [110816] = 6, - ACTIONS(373), 1, + [128101] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1298), 1, - sym__block_terminator, - STATE(2882), 2, + ACTIONS(4752), 1, + anon_sym_COLON, + STATE(3378), 2, sym_comment, sym_include, - [110836] = 6, - ACTIONS(373), 1, + [128118] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1295), 1, - sym__block_terminator, - STATE(2883), 2, + ACTIONS(4754), 1, + anon_sym_COLON, + STATE(3379), 2, sym_comment, sym_include, - [110856] = 6, - ACTIONS(373), 1, + [128135] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1286), 1, - sym__block_terminator, - STATE(2884), 2, + ACTIONS(4756), 1, + sym__terminator, + STATE(3380), 2, sym_comment, sym_include, - [110876] = 6, - ACTIONS(373), 1, + [128152] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3928), 1, - sym__terminator, - ACTIONS(3930), 1, - aux_sym_class_statement_token1, - STATE(2885), 2, + ACTIONS(4758), 1, + anon_sym_COLON, + STATE(3381), 2, sym_comment, sym_include, - [110896] = 6, - ACTIONS(373), 1, + [128169] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3932), 1, + ACTIONS(4690), 1, sym__terminator, - ACTIONS(3934), 1, - aux_sym_catch_statement_token1, - STATE(2886), 2, + STATE(3382), 2, sym_comment, sym_include, - [110916] = 6, - ACTIONS(373), 1, + [128186] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3936), 1, - sym__terminator, - ACTIONS(3938), 1, - aux_sym_finally_statement_token1, - STATE(2887), 2, + ACTIONS(4760), 1, + aux_sym_buffer_definition_token2, + STATE(3383), 2, sym_comment, sym_include, - [110936] = 6, - ACTIONS(3), 1, + [128203] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3367), 1, - anon_sym_RPAREN, - ACTIONS(3940), 1, - anon_sym_, - STATE(2888), 2, + ACTIONS(4762), 1, + sym__terminator, + STATE(3384), 2, sym_comment, sym_include, - [110956] = 6, - ACTIONS(373), 1, + [128220] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1180), 1, - sym__block_terminator, - STATE(2889), 2, + ACTIONS(4708), 1, + sym__terminator, + STATE(3385), 2, sym_comment, sym_include, - [110976] = 6, - ACTIONS(373), 1, + [128237] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1835), 1, - sym_query_fields, - STATE(2890), 2, + ACTIONS(4764), 1, + sym__terminator, + STATE(3386), 2, sym_comment, sym_include, - [110996] = 6, - ACTIONS(3), 1, + [128254] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3942), 1, - sym_identifier, - ACTIONS(3944), 1, - sym__terminator, - STATE(2891), 2, + ACTIONS(4766), 1, + anon_sym_DOT, + STATE(3387), 2, sym_comment, sym_include, - [111016] = 6, - ACTIONS(373), 1, + [128271] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3946), 1, - sym__terminator, - ACTIONS(3948), 1, - aux_sym_class_statement_token1, - STATE(2892), 2, + ACTIONS(4768), 1, + anon_sym_COLON, + STATE(3388), 2, sym_comment, sym_include, - [111036] = 6, - ACTIONS(373), 1, + [128288] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(966), 1, - sym__namedot, - STATE(585), 1, - aux_sym_qualified_name_repeat1, - STATE(2893), 2, + ACTIONS(4770), 1, + sym__terminator, + STATE(3389), 2, sym_comment, sym_include, - [111056] = 6, - ACTIONS(373), 1, + [128305] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1260), 1, - sym__block_terminator, - STATE(2894), 2, + ACTIONS(4772), 1, + sym__terminator, + STATE(3390), 2, sym_comment, sym_include, - [111076] = 6, - ACTIONS(373), 1, + [128322] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1259), 1, - sym__block_terminator, - STATE(2895), 2, + ACTIONS(4774), 1, + sym_identifier, + STATE(3391), 2, sym_comment, sym_include, - [111096] = 6, - ACTIONS(373), 1, + [128339] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1258), 1, - sym__block_terminator, - STATE(2896), 2, + ACTIONS(4776), 1, + sym__terminator, + STATE(3392), 2, sym_comment, sym_include, - [111116] = 6, - ACTIONS(373), 1, + [128356] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1257), 1, - sym__block_terminator, - STATE(2897), 2, + ACTIONS(4778), 1, + sym__terminator, + STATE(3393), 2, sym_comment, sym_include, - [111136] = 6, - ACTIONS(373), 1, + [128373] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1253), 1, - sym__block_terminator, - STATE(2898), 2, + ACTIONS(4780), 1, + anon_sym_RPAREN, + STATE(3394), 2, sym_comment, sym_include, - [111156] = 6, - ACTIONS(373), 1, + [128390] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1199), 1, - sym__block_terminator, - STATE(2899), 2, + ACTIONS(3725), 1, + aux_sym_of_token1, + STATE(3395), 2, sym_comment, sym_include, - [111176] = 6, - ACTIONS(373), 1, + [128407] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1201), 1, - sym__block_terminator, - STATE(2900), 2, + ACTIONS(4736), 1, + sym__terminator, + STATE(3396), 2, sym_comment, sym_include, - [111196] = 6, - ACTIONS(373), 1, + [128424] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1879), 1, - sym_query_fields, - STATE(2901), 2, + ACTIONS(4782), 1, + sym__terminator, + STATE(3397), 2, sym_comment, sym_include, - [111216] = 5, - ACTIONS(373), 1, + [128441] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1970), 2, - anon_sym_COMMA, + ACTIONS(4784), 1, anon_sym_COLON, - STATE(2902), 2, + STATE(3398), 2, sym_comment, sym_include, - [111234] = 6, - ACTIONS(373), 1, + [128458] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1236), 1, - sym__block_terminator, - STATE(2903), 2, + ACTIONS(4786), 1, + sym_identifier, + STATE(3399), 2, sym_comment, sym_include, - [111254] = 6, + [128475] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3950), 1, + ACTIONS(4788), 1, sym_identifier, - STATE(318), 1, - sym_qualified_name, - STATE(2904), 2, + STATE(3400), 2, sym_comment, sym_include, - [111274] = 5, - ACTIONS(373), 1, + [128492] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3952), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2905), 2, + ACTIONS(3089), 1, + anon_sym_COLON, + STATE(3401), 2, sym_comment, sym_include, - [111292] = 5, - ACTIONS(373), 1, + [128509] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3954), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2906), 2, + ACTIONS(4790), 1, + anon_sym_RBRACE, + STATE(3402), 2, + sym_comment, + sym_include, + [128526] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2867), 1, + anon_sym_COLON, + STATE(3403), 2, sym_comment, sym_include, - [111310] = 6, + [128543] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3956), 1, + ACTIONS(4792), 1, sym_identifier, - ACTIONS(3958), 1, - sym__integer_literal, - STATE(2907), 2, + STATE(3404), 2, sym_comment, sym_include, - [111330] = 5, - ACTIONS(373), 1, + [128560] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3960), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2908), 2, + ACTIONS(4036), 1, + anon_sym_LPAREN, + STATE(3405), 2, sym_comment, sym_include, - [111348] = 6, - ACTIONS(373), 1, + [128577] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3962), 1, - sym__terminator, - ACTIONS(3964), 1, - aux_sym_finally_statement_token1, - STATE(2909), 2, + ACTIONS(4794), 1, + anon_sym_COLON, + STATE(3406), 2, sym_comment, sym_include, - [111368] = 5, - ACTIONS(373), 1, + [128594] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3966), 2, - anon_sym_COMMA, + ACTIONS(4796), 1, anon_sym_COLON, - STATE(2910), 2, + STATE(3407), 2, sym_comment, sym_include, - [111386] = 5, - ACTIONS(373), 1, + [128611] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3968), 2, - aux_sym_on_error_phrase_token2, - aux_sym_on_error_phrase_token7, - STATE(2911), 2, + ACTIONS(4798), 1, + anon_sym_COLON, + STATE(3408), 2, sym_comment, sym_include, - [111404] = 6, - ACTIONS(3), 1, + [128628] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3970), 1, - sym_identifier, - ACTIONS(3972), 1, - sym__terminator, - STATE(2912), 2, + ACTIONS(3555), 1, + anon_sym_COLON, + STATE(3409), 2, sym_comment, sym_include, - [111424] = 6, - ACTIONS(373), 1, + [128645] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1221), 1, - sym__block_terminator, - STATE(2913), 2, + ACTIONS(4800), 1, + anon_sym_DOT, + STATE(3410), 2, sym_comment, sym_include, - [111444] = 6, - ACTIONS(373), 1, + [128662] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3844), 1, - aux_sym__block_terminator_token1, - STATE(1219), 1, - sym__block_terminator, - STATE(2914), 2, + ACTIONS(2794), 1, + anon_sym_COLON, + STATE(3411), 2, sym_comment, sym_include, - [111464] = 6, - ACTIONS(373), 1, + [128679] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1196), 1, - sym__block_terminator, - STATE(2915), 2, + ACTIONS(4802), 1, + anon_sym_COMMA, + STATE(3412), 2, sym_comment, sym_include, - [111484] = 5, - ACTIONS(373), 1, + [128696] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3974), 2, + ACTIONS(4030), 1, sym__terminator, + STATE(3413), 2, + sym_comment, + sym_include, + [128713] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4804), 1, anon_sym_COLON, - STATE(2916), 2, + STATE(3414), 2, sym_comment, sym_include, - [111502] = 6, - ACTIONS(373), 1, + [128730] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1195), 1, - sym__block_terminator, - STATE(2917), 2, + ACTIONS(4806), 1, + sym_identifier, + STATE(3415), 2, sym_comment, sym_include, - [111522] = 6, - ACTIONS(373), 1, + [128747] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3976), 1, + ACTIONS(4808), 1, sym__terminator, - ACTIONS(3978), 1, - aux_sym_catch_statement_token1, - STATE(2918), 2, + STATE(3416), 2, sym_comment, sym_include, - [111542] = 6, - ACTIONS(373), 1, + [128764] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1113), 1, - sym__block_terminator, - STATE(2919), 2, + ACTIONS(4810), 1, + anon_sym_RPAREN, + STATE(3417), 2, sym_comment, sym_include, - [111562] = 6, - ACTIONS(373), 1, + [128781] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1008), 1, - sym__block_terminator, - STATE(2920), 2, + ACTIONS(4038), 1, + anon_sym_COLON, + STATE(3418), 2, sym_comment, sym_include, - [111582] = 6, - ACTIONS(3), 1, + [128798] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3980), 1, - sym_identifier, - STATE(341), 1, - sym_function_call, - STATE(2921), 2, + ACTIONS(4704), 1, + sym__terminator, + STATE(3419), 2, sym_comment, sym_include, - [111602] = 6, - ACTIONS(3), 1, + [128815] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3982), 1, - sym_identifier, - STATE(273), 1, - sym_qualified_name, - STATE(2922), 2, + ACTIONS(4812), 1, + sym__terminator, + STATE(3420), 2, sym_comment, sym_include, - [111622] = 6, - ACTIONS(373), 1, + [128832] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1009), 1, - sym__block_terminator, - STATE(2923), 2, + ACTIONS(4814), 1, + anon_sym_COLON, + STATE(3421), 2, sym_comment, sym_include, - [111642] = 6, - ACTIONS(373), 1, + [128849] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1012), 1, - sym__block_terminator, - STATE(2924), 2, + ACTIONS(4816), 1, + sym__integer_literal, + STATE(3422), 2, sym_comment, sym_include, - [111662] = 6, - ACTIONS(373), 1, + [128866] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1013), 1, - sym__block_terminator, - STATE(2925), 2, + ACTIONS(4818), 1, + anon_sym_COLON, + STATE(3423), 2, sym_comment, sym_include, - [111682] = 6, - ACTIONS(373), 1, + [128883] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1014), 1, - sym__block_terminator, - STATE(2926), 2, + ACTIONS(4020), 1, + anon_sym_COLON, + STATE(3424), 2, + sym_comment, + sym_include, + [128900] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2817), 1, + anon_sym_COLON, + STATE(3425), 2, sym_comment, sym_include, - [111702] = 6, + [128917] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3984), 1, + ACTIONS(4820), 1, sym_identifier, - ACTIONS(3986), 1, - anon_sym_RPAREN, - STATE(2927), 2, + STATE(3426), 2, sym_comment, sym_include, - [111722] = 6, - ACTIONS(373), 1, + [128934] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1864), 1, - sym_query_fields, - STATE(2928), 2, + ACTIONS(4822), 1, + anon_sym_COMMA, + STATE(3427), 2, sym_comment, sym_include, - [111742] = 5, - ACTIONS(373), 1, + [128951] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1996), 2, - anon_sym_COMMA, + ACTIONS(4824), 1, anon_sym_COLON, - STATE(2929), 2, + STATE(3428), 2, sym_comment, sym_include, - [111760] = 6, - ACTIONS(373), 1, + [128968] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1032), 1, - sym__block_terminator, - STATE(2930), 2, + ACTIONS(4826), 1, + anon_sym_RBRACE, + STATE(3429), 2, sym_comment, sym_include, - [111780] = 5, - ACTIONS(373), 1, + [128985] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(1666), 2, - aux_sym_buffer_definition_token2, - aux_sym_repeat_statement_token1, - STATE(2931), 2, + ACTIONS(4828), 1, + sym__terminator, + STATE(3430), 2, sym_comment, sym_include, - [111798] = 6, - ACTIONS(3), 1, + [129002] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3112), 1, + ACTIONS(4830), 1, anon_sym_COLON, - ACTIONS(3988), 1, - sym_identifier, - STATE(2932), 2, + STATE(3431), 2, sym_comment, sym_include, - [111818] = 5, - ACTIONS(373), 1, + [129019] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3990), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2933), 2, + ACTIONS(4832), 1, + sym__terminator, + STATE(3432), 2, sym_comment, sym_include, - [111836] = 6, - ACTIONS(373), 1, + [129036] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3992), 1, - anon_sym_DOT, - ACTIONS(3994), 1, - aux_sym__function_terminator_token1, - STATE(2934), 2, + ACTIONS(4678), 1, + sym__terminator, + STATE(3433), 2, sym_comment, sym_include, - [111856] = 5, - ACTIONS(373), 1, + [129053] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3996), 2, - anon_sym_COMMA, + ACTIONS(2802), 1, anon_sym_COLON, - STATE(2935), 2, + STATE(3434), 2, sym_comment, sym_include, - [111874] = 5, - ACTIONS(373), 1, + [129070] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3998), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(2936), 2, + ACTIONS(4834), 1, + sym__terminator, + STATE(3435), 2, sym_comment, sym_include, - [111892] = 6, - ACTIONS(3), 1, + [129087] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3053), 1, - anon_sym_COLON, - ACTIONS(4000), 1, - sym_identifier, - STATE(2937), 2, + ACTIONS(4836), 1, + sym__terminator, + STATE(3436), 2, sym_comment, sym_include, - [111912] = 6, - ACTIONS(373), 1, + [129104] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3794), 1, - anon_sym_DOT, - ACTIONS(4002), 1, - aux_sym__function_terminator_token1, - STATE(2938), 2, + ACTIONS(4838), 1, + anon_sym_COLON, + STATE(3437), 2, sym_comment, sym_include, - [111932] = 6, + [129121] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3203), 1, - anon_sym_COLON, - ACTIONS(4004), 1, + ACTIONS(4840), 1, sym_identifier, - STATE(2939), 2, + STATE(3438), 2, sym_comment, sym_include, - [111952] = 5, - ACTIONS(373), 1, + [129138] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3420), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(2940), 2, + ACTIONS(4842), 1, + sym__terminator, + STATE(3439), 2, sym_comment, sym_include, - [111970] = 6, - ACTIONS(373), 1, + [129155] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3992), 1, - anon_sym_DOT, - ACTIONS(4006), 1, - aux_sym__case_terminator_token1, - STATE(2941), 2, + ACTIONS(4844), 1, + anon_sym_COLON, + STATE(3440), 2, sym_comment, sym_include, - [111990] = 6, - ACTIONS(373), 1, + [129172] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3992), 1, - anon_sym_DOT, - ACTIONS(4008), 1, - aux_sym__procedure_terminator_token1, - STATE(2942), 2, + ACTIONS(4846), 1, + anon_sym_COLON, + STATE(3441), 2, sym_comment, sym_include, - [112010] = 6, - ACTIONS(373), 1, + [129189] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1067), 1, - sym__block_terminator, - STATE(2943), 2, + ACTIONS(3414), 1, + anon_sym_COLON, + STATE(3442), 2, sym_comment, sym_include, - [112030] = 6, - ACTIONS(373), 1, + [129206] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1138), 1, - sym__block_terminator, - STATE(2944), 2, + ACTIONS(4848), 1, + sym_identifier, + STATE(3443), 2, sym_comment, sym_include, - [112050] = 6, - ACTIONS(373), 1, + [129223] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1136), 1, - sym__block_terminator, - STATE(2945), 2, + ACTIONS(4850), 1, + sym__terminator, + STATE(3444), 2, sym_comment, sym_include, - [112070] = 6, - ACTIONS(373), 1, + [129240] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1135), 1, - sym__block_terminator, - STATE(2946), 2, + ACTIONS(4852), 1, + aux_sym_do_while_statement_token1, + STATE(3445), 2, sym_comment, sym_include, - [112090] = 5, - ACTIONS(373), 1, + [129257] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4010), 2, - anon_sym_COMMA, + ACTIONS(4854), 1, + sym__terminator, + STATE(3446), 2, + sym_comment, + sym_include, + [129274] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3463), 1, anon_sym_COLON, - STATE(2947), 2, + STATE(3447), 2, sym_comment, sym_include, - [112108] = 6, - ACTIONS(373), 1, + [129291] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1132), 1, - sym__block_terminator, - STATE(2948), 2, + ACTIONS(4856), 1, + anon_sym_COLON, + STATE(3448), 2, sym_comment, sym_include, - [112128] = 6, - ACTIONS(373), 1, + [129308] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, + ACTIONS(4858), 1, aux_sym__block_terminator_token1, - STATE(1130), 1, - sym__block_terminator, - STATE(2949), 2, + STATE(3449), 2, sym_comment, sym_include, - [112148] = 5, - ACTIONS(373), 1, + [129325] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3088), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2950), 2, + ACTIONS(4860), 1, + sym__terminator, + STATE(3450), 2, sym_comment, sym_include, - [112166] = 5, - ACTIONS(373), 1, + [129342] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4012), 2, + ACTIONS(4064), 1, sym__terminator, - anon_sym_COLON, - STATE(2951), 2, + STATE(3451), 2, sym_comment, sym_include, - [112184] = 6, - ACTIONS(373), 1, + [129359] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1125), 1, - sym__block_terminator, - STATE(2952), 2, + ACTIONS(4862), 1, + anon_sym_COLON, + STATE(3452), 2, sym_comment, sym_include, - [112204] = 6, - ACTIONS(373), 1, + [129376] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1122), 1, - sym__block_terminator, - STATE(2953), 2, + ACTIONS(4864), 1, + anon_sym_LPAREN, + STATE(3453), 2, sym_comment, sym_include, - [112224] = 5, - ACTIONS(373), 1, + [129393] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2896), 2, - anon_sym_COMMA, + ACTIONS(4866), 1, anon_sym_COLON, - STATE(2954), 2, + STATE(3454), 2, sym_comment, sym_include, - [112242] = 6, - ACTIONS(373), 1, + [129410] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1115), 1, - sym__block_terminator, - STATE(2955), 2, + ACTIONS(4868), 1, + anon_sym_COLON, + STATE(3455), 2, sym_comment, sym_include, - [112262] = 6, - ACTIONS(373), 1, + [129427] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1111), 1, - sym__block_terminator, - STATE(2956), 2, + ACTIONS(4870), 1, + sym__terminator, + STATE(3456), 2, sym_comment, sym_include, - [112282] = 5, - ACTIONS(373), 1, + [129444] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2443), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2957), 2, + ACTIONS(3874), 1, + aux_sym_on_stop_phrase_token1, + STATE(3457), 2, sym_comment, sym_include, - [112300] = 6, - ACTIONS(373), 1, + [129461] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1101), 1, - sym__block_terminator, - STATE(2958), 2, + ACTIONS(4872), 1, + sym__terminator, + STATE(3458), 2, sym_comment, sym_include, - [112320] = 6, - ACTIONS(373), 1, + [129478] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4014), 1, + ACTIONS(4874), 1, sym__terminator, - ACTIONS(4016), 1, - aux_sym_catch_statement_token1, - STATE(2959), 2, + STATE(3459), 2, sym_comment, sym_include, - [112340] = 6, - ACTIONS(373), 1, + [129495] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1094), 1, - sym__block_terminator, - STATE(2960), 2, + ACTIONS(3741), 1, + anon_sym_COLON, + STATE(3460), 2, sym_comment, sym_include, - [112360] = 6, - ACTIONS(373), 1, + [129512] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1050), 1, - sym__block_terminator, - STATE(2961), 2, + ACTIONS(4876), 1, + anon_sym_COLON, + STATE(3461), 2, sym_comment, sym_include, - [112380] = 5, - ACTIONS(373), 1, + [129529] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2068), 2, - anon_sym_COMMA, + ACTIONS(4878), 1, anon_sym_COLON, - STATE(2962), 2, + STATE(3462), 2, sym_comment, sym_include, - [112398] = 6, - ACTIONS(373), 1, + [129546] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1057), 1, - sym__block_terminator, - STATE(2963), 2, + ACTIONS(4880), 1, + anon_sym_COLON, + STATE(3463), 2, sym_comment, sym_include, - [112418] = 6, - ACTIONS(373), 1, + [129563] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3574), 1, - anon_sym_LPAREN, - STATE(1920), 1, - sym_query_fields, - STATE(2964), 2, + ACTIONS(4882), 1, + anon_sym_DOT, + STATE(3464), 2, sym_comment, sym_include, - [112438] = 6, - ACTIONS(373), 1, + [129580] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3670), 1, - aux_sym__block_terminator_token1, - STATE(1080), 1, - sym__block_terminator, - STATE(2965), 2, + ACTIONS(4884), 1, + sym__terminator, + STATE(3465), 2, sym_comment, sym_include, - [112458] = 5, - ACTIONS(373), 1, + [129597] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2066), 2, - anon_sym_COMMA, - anon_sym_COLON, - STATE(2966), 2, + ACTIONS(4886), 1, + anon_sym_EQ, + STATE(3466), 2, sym_comment, sym_include, - [112476] = 6, - ACTIONS(373), 1, + [129614] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4018), 1, + ACTIONS(4614), 1, sym__terminator, - ACTIONS(4020), 1, - aux_sym_catch_statement_token1, - STATE(2967), 2, + STATE(3467), 2, sym_comment, sym_include, - [112496] = 5, - ACTIONS(373), 1, + [129631] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4022), 2, - anon_sym_RPAREN, - anon_sym_COMMA, - STATE(2968), 2, + ACTIONS(2841), 1, + anon_sym_COLON, + STATE(3468), 2, sym_comment, sym_include, - [112514] = 5, - ACTIONS(373), 1, + [129648] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4024), 1, + ACTIONS(4076), 1, anon_sym_COLON, - STATE(2969), 2, + STATE(3469), 2, sym_comment, sym_include, - [112531] = 5, - ACTIONS(373), 1, + [129665] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4026), 1, - sym__integer_literal, - STATE(2970), 2, + ACTIONS(4888), 1, + sym_identifier, + STATE(3470), 2, sym_comment, sym_include, - [112548] = 5, - ACTIONS(373), 1, + [129682] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4028), 1, - aux_sym_input_expression_token2, - STATE(2971), 2, + ACTIONS(4890), 1, + anon_sym_COLON, + STATE(3471), 2, sym_comment, sym_include, - [112565] = 5, - ACTIONS(3), 1, + [129699] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4030), 1, - sym_identifier, - STATE(2972), 2, + ACTIONS(4892), 1, + anon_sym_COLON, + STATE(3472), 2, sym_comment, sym_include, - [112582] = 5, - ACTIONS(373), 1, + [129716] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4032), 1, + ACTIONS(4894), 1, anon_sym_COLON, - STATE(2973), 2, + STATE(3473), 2, sym_comment, sym_include, - [112599] = 5, - ACTIONS(373), 1, + [129733] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4034), 1, + ACTIONS(4896), 1, anon_sym_COLON, - STATE(2974), 2, + STATE(3474), 2, sym_comment, sym_include, - [112616] = 5, - ACTIONS(373), 1, + [129750] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4036), 1, - anon_sym_COLON, - STATE(2975), 2, + ACTIONS(4898), 1, + sym_identifier, + STATE(3475), 2, sym_comment, sym_include, - [112633] = 5, + [129767] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4038), 1, + ACTIONS(4900), 1, sym_identifier, - STATE(2976), 2, + STATE(3476), 2, sym_comment, sym_include, - [112650] = 5, - ACTIONS(373), 1, + [129784] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4014), 1, - sym__terminator, - STATE(2977), 2, + ACTIONS(4902), 1, + anon_sym_LPAREN, + STATE(3477), 2, sym_comment, sym_include, - [112667] = 5, - ACTIONS(373), 1, + [129801] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4040), 1, - sym__terminator, - STATE(2978), 2, + ACTIONS(4904), 1, + sym_identifier, + STATE(3478), 2, sym_comment, sym_include, - [112684] = 5, - ACTIONS(373), 1, + [129818] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4042), 1, - aux_sym_input_expression_token2, - STATE(2979), 2, + ACTIONS(4906), 1, + anon_sym_COLON, + STATE(3479), 2, sym_comment, sym_include, - [112701] = 5, - ACTIONS(373), 1, + [129835] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4044), 1, - anon_sym_COLON, - STATE(2980), 2, + ACTIONS(4908), 1, + anon_sym_RBRACE, + STATE(3480), 2, sym_comment, sym_include, - [112718] = 5, - ACTIONS(373), 1, + [129852] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4046), 1, - anon_sym_COLON, - STATE(2981), 2, + ACTIONS(4910), 1, + sym__terminator, + STATE(3481), 2, sym_comment, sym_include, - [112735] = 5, - ACTIONS(373), 1, + [129869] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4048), 1, - anon_sym_COLON, - STATE(2982), 2, + ACTIONS(4912), 1, + sym__terminator, + STATE(3482), 2, sym_comment, sym_include, - [112752] = 5, + [129886] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4050), 1, + ACTIONS(4914), 1, sym_identifier, - STATE(2983), 2, + STATE(3483), 2, sym_comment, sym_include, - [112769] = 5, - ACTIONS(373), 1, + [129903] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3416), 1, + ACTIONS(2833), 1, anon_sym_COLON, - STATE(2984), 2, + STATE(3484), 2, sym_comment, sym_include, - [112786] = 5, - ACTIONS(373), 1, + [129920] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4052), 1, + ACTIONS(3477), 1, anon_sym_COLON, - STATE(2985), 2, + STATE(3485), 2, sym_comment, sym_include, - [112803] = 5, - ACTIONS(373), 1, + [129937] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4054), 1, + ACTIONS(4916), 1, anon_sym_COLON, - STATE(2986), 2, - sym_comment, - sym_include, - [112820] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4056), 1, - sym__terminator, - STATE(2987), 2, + STATE(3486), 2, sym_comment, sym_include, - [112837] = 5, - ACTIONS(373), 1, + [129954] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4058), 1, + ACTIONS(4918), 1, sym__terminator, - STATE(2988), 2, + STATE(3487), 2, sym_comment, sym_include, - [112854] = 5, - ACTIONS(373), 1, + [129971] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4060), 1, - sym__terminator, - STATE(2989), 2, + ACTIONS(4920), 1, + anon_sym_LPAREN, + STATE(3488), 2, sym_comment, sym_include, - [112871] = 5, - ACTIONS(373), 1, + [129988] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4062), 1, - anon_sym_EQ, - STATE(2990), 2, + ACTIONS(4922), 1, + aux_sym_buffer_definition_token2, + STATE(3489), 2, sym_comment, sym_include, - [112888] = 5, + [130005] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4064), 1, + ACTIONS(4924), 1, sym_identifier, - STATE(2991), 2, + STATE(3490), 2, sym_comment, sym_include, - [112905] = 5, - ACTIONS(373), 1, + [130022] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4066), 1, - sym__terminator, - STATE(2992), 2, + ACTIONS(4093), 1, + anon_sym_LPAREN, + STATE(3491), 2, sym_comment, sym_include, - [112922] = 5, - ACTIONS(373), 1, + [130039] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4068), 1, - sym__terminator, - STATE(2993), 2, + ACTIONS(4926), 1, + sym_identifier, + STATE(3492), 2, sym_comment, sym_include, - [112939] = 5, - ACTIONS(373), 1, + [130056] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4070), 1, - anon_sym_RBRACE, - STATE(2994), 2, + ACTIONS(4928), 1, + aux_sym__block_terminator_token1, + STATE(3493), 2, sym_comment, sym_include, - [112956] = 5, - ACTIONS(3), 1, + [130073] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4072), 1, - sym_identifier, - STATE(2995), 2, + ACTIONS(2784), 1, + anon_sym_COLON, + STATE(3494), 2, sym_comment, sym_include, - [112973] = 5, - ACTIONS(373), 1, + [130090] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4074), 1, - sym__integer_literal, - STATE(2996), 2, + ACTIONS(4930), 1, + sym_identifier, + STATE(3495), 2, sym_comment, sym_include, - [112990] = 5, - ACTIONS(373), 1, + [130107] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4076), 1, - anon_sym_RPAREN, - STATE(2997), 2, + ACTIONS(3169), 1, + anon_sym_COLON, + STATE(3496), 2, sym_comment, sym_include, - [113007] = 5, - ACTIONS(373), 1, + [130124] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4078), 1, - aux_sym__block_terminator_token1, - STATE(2998), 2, + ACTIONS(4932), 1, + aux_sym_on_error_phrase_token3, + STATE(3497), 2, sym_comment, sym_include, - [113024] = 5, - ACTIONS(373), 1, + [130141] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4080), 1, - sym__terminator, - STATE(2999), 2, + ACTIONS(4934), 1, + aux_sym_on_error_phrase_token3, + STATE(3498), 2, sym_comment, sym_include, - [113041] = 5, - ACTIONS(373), 1, + [130158] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3156), 1, - anon_sym_COLON, - STATE(3000), 2, + ACTIONS(4936), 1, + sym_identifier, + STATE(3499), 2, sym_comment, sym_include, - [113058] = 5, - ACTIONS(373), 1, + [130175] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4018), 1, - sym__terminator, - STATE(3001), 2, + ACTIONS(4938), 1, + aux_sym_function_parameter_token1, + STATE(3500), 2, sym_comment, sym_include, - [113075] = 5, + [130192] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4082), 1, + ACTIONS(4940), 1, sym_identifier, - STATE(3002), 2, + STATE(3501), 2, sym_comment, sym_include, - [113092] = 5, - ACTIONS(373), 1, + [130209] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4084), 1, + ACTIONS(4590), 1, sym__terminator, - STATE(3003), 2, + STATE(3502), 2, sym_comment, sym_include, - [113109] = 5, - ACTIONS(373), 1, + [130226] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4086), 1, - sym__terminator, - STATE(3004), 2, + ACTIONS(4262), 1, + anon_sym_DOT, + STATE(3503), 2, sym_comment, sym_include, - [113126] = 5, - ACTIONS(373), 1, + [130243] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3992), 1, - anon_sym_DOT, - STATE(3005), 2, + ACTIONS(4942), 1, + aux_sym__block_terminator_token1, + STATE(3504), 2, sym_comment, sym_include, - [113143] = 5, - ACTIONS(373), 1, + [130260] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4088), 1, - aux_sym_variable_definition_token5, - STATE(3006), 2, + ACTIONS(4944), 1, + sym__terminator, + STATE(3505), 2, sym_comment, sym_include, - [113160] = 5, - ACTIONS(373), 1, + [130277] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4090), 1, - anon_sym_COLON, - STATE(3007), 2, + ACTIONS(4121), 1, + sym__terminator, + STATE(3506), 2, sym_comment, sym_include, - [113177] = 5, - ACTIONS(373), 1, + [130294] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4092), 1, - sym__terminator, - STATE(3008), 2, + ACTIONS(4946), 1, + anon_sym_COLON, + STATE(3507), 2, sym_comment, sym_include, - [113194] = 5, - ACTIONS(373), 1, + [130311] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3237), 1, - anon_sym_LPAREN, - STATE(3009), 2, + ACTIONS(4948), 1, + anon_sym_RPAREN, + STATE(3508), 2, sym_comment, sym_include, - [113211] = 5, + [130328] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4094), 1, + ACTIONS(4950), 1, sym_identifier, - STATE(3010), 2, + STATE(3509), 2, sym_comment, sym_include, - [113228] = 5, - ACTIONS(373), 1, + [130345] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4096), 1, - anon_sym_RBRACE, - STATE(3011), 2, + ACTIONS(4952), 1, + sym__terminator, + STATE(3510), 2, sym_comment, sym_include, - [113245] = 5, - ACTIONS(373), 1, + [130362] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4098), 1, - anon_sym_COLON, - STATE(3012), 2, + ACTIONS(4954), 1, + aux_sym_do_while_statement_token1, + STATE(3511), 2, sym_comment, sym_include, - [113262] = 5, - ACTIONS(373), 1, + [130379] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2673), 1, - anon_sym_COLON, - STATE(3013), 2, + ACTIONS(3968), 1, + sym__terminator, + STATE(3512), 2, sym_comment, sym_include, - [113279] = 5, - ACTIONS(373), 1, + [130396] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4100), 1, + ACTIONS(4956), 1, sym__terminator, - STATE(3014), 2, + STATE(3513), 2, sym_comment, sym_include, - [113296] = 5, - ACTIONS(373), 1, + [130413] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4102), 1, + ACTIONS(4125), 1, sym__terminator, - STATE(3015), 2, + STATE(3514), 2, + sym_comment, + sym_include, + [130430] = 5, + ACTIONS(3), 1, + anon_sym_SLASH_SLASH, + ACTIONS(5), 1, + anon_sym_SLASH_STAR, + ACTIONS(7), 1, + anon_sym_LBRACE, + ACTIONS(4958), 1, + sym_identifier, + STATE(3515), 2, sym_comment, sym_include, - [113313] = 5, - ACTIONS(373), 1, + [130447] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3451), 1, + ACTIONS(4960), 1, sym__terminator, - STATE(3016), 2, + STATE(3516), 2, sym_comment, sym_include, - [113330] = 5, - ACTIONS(3), 1, + [130464] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4104), 1, - sym_identifier, - STATE(3017), 2, + ACTIONS(4962), 1, + aux_sym_buffer_definition_token2, + STATE(3517), 2, sym_comment, sym_include, - [113347] = 5, + [130481] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4106), 1, + ACTIONS(4964), 1, sym_identifier, - STATE(3018), 2, + STATE(3518), 2, sym_comment, sym_include, - [113364] = 5, - ACTIONS(373), 1, + [130498] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4108), 1, + ACTIONS(4966), 1, sym__terminator, - STATE(3019), 2, + STATE(3519), 2, sym_comment, sym_include, - [113381] = 5, - ACTIONS(373), 1, + [130515] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4110), 1, - sym__terminator, - STATE(3020), 2, + ACTIONS(4968), 1, + aux_sym_variable_definition_token5, + STATE(3520), 2, sym_comment, sym_include, - [113398] = 5, - ACTIONS(373), 1, + [130532] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4112), 1, - anon_sym_COLON, - STATE(3021), 2, + ACTIONS(4970), 1, + sym__terminator, + STATE(3521), 2, sym_comment, sym_include, - [113415] = 5, - ACTIONS(373), 1, + [130549] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4114), 1, + ACTIONS(4972), 1, sym__terminator, - STATE(3022), 2, + STATE(3522), 2, sym_comment, sym_include, - [113432] = 5, - ACTIONS(373), 1, + [130566] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4116), 1, - sym__terminator, - STATE(3023), 2, + ACTIONS(4974), 1, + sym_identifier, + STATE(3523), 2, sym_comment, sym_include, - [113449] = 5, - ACTIONS(373), 1, + [130583] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4118), 1, - sym__terminator, - STATE(3024), 2, + ACTIONS(4976), 1, + sym_identifier, + STATE(3524), 2, sym_comment, sym_include, - [113466] = 5, - ACTIONS(373), 1, + [130600] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3936), 1, + ACTIONS(4978), 1, sym__terminator, - STATE(3025), 2, + STATE(3525), 2, sym_comment, sym_include, - [113483] = 5, - ACTIONS(373), 1, + [130617] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4120), 1, - aux_sym__block_terminator_token1, - STATE(3026), 2, + ACTIONS(4980), 1, + sym__terminator, + STATE(3526), 2, sym_comment, sym_include, - [113500] = 5, - ACTIONS(373), 1, + [130634] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4122), 1, - anon_sym_RPAREN, - STATE(3027), 2, + ACTIONS(3119), 1, + anon_sym_COLON, + STATE(3527), 2, sym_comment, sym_include, - [113517] = 5, - ACTIONS(373), 1, + [130651] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4124), 1, + ACTIONS(4982), 1, aux_sym__block_terminator_token1, - STATE(3028), 2, - sym_comment, - sym_include, - [113534] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3509), 1, - sym__terminator, - STATE(3029), 2, + STATE(3528), 2, sym_comment, sym_include, - [113551] = 5, - ACTIONS(373), 1, + [130668] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4126), 1, - sym__terminator, - STATE(3030), 2, + ACTIONS(2858), 1, + anon_sym_COLON, + STATE(3529), 2, sym_comment, sym_include, - [113568] = 5, - ACTIONS(373), 1, + [130685] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4128), 1, - anon_sym_DOT, - STATE(3031), 2, + ACTIONS(4984), 1, + aux_sym_input_expression_token2, + STATE(3530), 2, sym_comment, sym_include, - [113585] = 5, - ACTIONS(373), 1, + [130702] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4130), 1, - sym__terminator, - STATE(3032), 2, + ACTIONS(4986), 1, + sym_identifier, + STATE(3531), 2, sym_comment, sym_include, - [113602] = 5, - ACTIONS(373), 1, + [130719] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4132), 1, - sym__terminator, - STATE(3033), 2, + ACTIONS(4988), 1, + sym_identifier, + STATE(3532), 2, sym_comment, sym_include, - [113619] = 5, + [130736] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4134), 1, + ACTIONS(4990), 1, sym_identifier, - STATE(3034), 2, + STATE(3533), 2, sym_comment, sym_include, - [113636] = 5, - ACTIONS(373), 1, + [130753] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(2679), 1, - anon_sym_COLON, - STATE(3035), 2, + ACTIONS(4992), 1, + sym_identifier, + STATE(3534), 2, sym_comment, sym_include, - [113653] = 5, + [130770] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4136), 1, + ACTIONS(4994), 1, sym_identifier, - STATE(3036), 2, + STATE(3535), 2, sym_comment, sym_include, - [113670] = 5, - ACTIONS(373), 1, + [130787] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4138), 1, - anon_sym_COLON, - STATE(3037), 2, + ACTIONS(4996), 1, + sym__integer_literal, + STATE(3536), 2, sym_comment, sym_include, - [113687] = 5, - ACTIONS(373), 1, + [130804] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3918), 1, - sym__terminator, - STATE(3038), 2, + ACTIONS(3957), 1, + anon_sym_LPAREN, + STATE(3537), 2, sym_comment, sym_include, - [113704] = 5, - ACTIONS(373), 1, + [130821] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4140), 1, + ACTIONS(4998), 1, sym__terminator, - STATE(3039), 2, + STATE(3538), 2, sym_comment, sym_include, - [113721] = 5, - ACTIONS(3), 1, + [130838] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4142), 1, - sym_identifier, - STATE(3040), 2, + ACTIONS(2935), 1, + aux_sym_property_definition_token1, + STATE(3539), 2, sym_comment, sym_include, - [113738] = 5, - ACTIONS(373), 1, + [130855] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4144), 1, - aux_sym_variable_definition_token5, - STATE(3041), 2, + ACTIONS(5000), 1, + sym__terminator, + STATE(3540), 2, sym_comment, sym_include, - [113755] = 5, - ACTIONS(373), 1, + [130872] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3363), 1, - anon_sym_LPAREN, - STATE(3042), 2, + ACTIONS(5002), 1, + sym__terminator, + STATE(3541), 2, sym_comment, sym_include, - [113772] = 5, - ACTIONS(373), 1, + [130889] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4146), 1, - sym__terminator, - STATE(3043), 2, + ACTIONS(5004), 1, + anon_sym_COLON, + STATE(3542), 2, sym_comment, sym_include, - [113789] = 5, - ACTIONS(373), 1, + [130906] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4148), 1, + ACTIONS(5006), 1, sym__terminator, - STATE(3044), 2, + STATE(3543), 2, sym_comment, sym_include, - [113806] = 5, - ACTIONS(373), 1, + [130923] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4150), 1, - sym__terminator, - STATE(3045), 2, + ACTIONS(3467), 1, + anon_sym_COLON, + STATE(3544), 2, sym_comment, sym_include, - [113823] = 5, - ACTIONS(373), 1, + [130940] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4152), 1, - sym__terminator, - STATE(3046), 2, + ACTIONS(5008), 1, + anon_sym_RBRACE, + STATE(3545), 2, sym_comment, sym_include, - [113840] = 5, - ACTIONS(373), 1, + [130957] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4154), 1, + ACTIONS(2843), 1, anon_sym_COLON, - STATE(3047), 2, + STATE(3546), 2, sym_comment, sym_include, - [113857] = 5, - ACTIONS(373), 1, + [130974] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3473), 1, + ACTIONS(5010), 1, sym__terminator, - STATE(3048), 2, + STATE(3547), 2, sym_comment, sym_include, - [113874] = 5, - ACTIONS(373), 1, + [130991] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3080), 1, - anon_sym_COLON, - STATE(3049), 2, + ACTIONS(5012), 1, + sym_identifier, + STATE(3548), 2, sym_comment, sym_include, - [113891] = 5, - ACTIONS(373), 1, + [131008] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3487), 1, - sym__terminator, - STATE(3050), 2, + ACTIONS(5014), 1, + anon_sym_COLON, + STATE(3549), 2, sym_comment, sym_include, - [113908] = 5, - ACTIONS(373), 1, + [131025] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4156), 1, - sym__terminator, - STATE(3051), 2, + ACTIONS(5016), 1, + anon_sym_COMMA, + STATE(3550), 2, sym_comment, sym_include, - [113925] = 5, - ACTIONS(373), 1, + [131042] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4158), 1, + ACTIONS(5018), 1, sym__terminator, - STATE(3052), 2, + STATE(3551), 2, sym_comment, sym_include, - [113942] = 5, - ACTIONS(373), 1, + [131059] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4160), 1, - sym__terminator, - STATE(3053), 2, + ACTIONS(5020), 1, + sym_identifier, + STATE(3552), 2, sym_comment, sym_include, - [113959] = 5, - ACTIONS(373), 1, + [131076] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4162), 1, - sym__terminator, - STATE(3054), 2, + ACTIONS(5022), 1, + anon_sym_COLON, + STATE(3553), 2, sym_comment, sym_include, - [113976] = 5, - ACTIONS(373), 1, + [131093] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3463), 1, - sym__terminator, - STATE(3055), 2, + ACTIONS(5024), 1, + sym_identifier, + STATE(3554), 2, sym_comment, sym_include, - [113993] = 5, - ACTIONS(373), 1, + [131110] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4164), 1, - sym__terminator, - STATE(3056), 2, + ACTIONS(5026), 1, + aux_sym_buffer_definition_token2, + STATE(3555), 2, sym_comment, sym_include, - [114010] = 5, - ACTIONS(373), 1, + [131127] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4166), 1, - anon_sym_COLON, - STATE(3057), 2, + ACTIONS(5028), 1, + anon_sym_RBRACE, + STATE(3556), 2, sym_comment, sym_include, - [114027] = 5, - ACTIONS(373), 1, + [131144] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3556), 1, - sym__terminator, - STATE(3058), 2, + ACTIONS(5030), 1, + sym_identifier, + STATE(3557), 2, sym_comment, sym_include, - [114044] = 5, - ACTIONS(373), 1, + [131161] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3548), 1, + ACTIONS(5032), 1, sym__terminator, - STATE(3059), 2, + STATE(3558), 2, sym_comment, sym_include, - [114061] = 5, - ACTIONS(373), 1, + [131178] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4168), 1, - sym__terminator, - STATE(3060), 2, + ACTIONS(5034), 1, + anon_sym_COLON, + STATE(3559), 2, sym_comment, sym_include, - [114078] = 5, - ACTIONS(373), 1, + [131195] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4170), 1, - anon_sym_COMMA, - STATE(3061), 2, + ACTIONS(5036), 1, + aux_sym__block_terminator_token1, + STATE(3560), 2, sym_comment, sym_include, - [114095] = 5, - ACTIONS(373), 1, + [131212] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4172), 1, - sym__terminator, - STATE(3062), 2, + ACTIONS(5038), 1, + anon_sym_LPAREN, + STATE(3561), 2, sym_comment, sym_include, - [114112] = 5, - ACTIONS(3), 1, + [131229] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4174), 1, - sym_identifier, - STATE(3063), 2, + ACTIONS(5040), 1, + anon_sym_RPAREN, + STATE(3562), 2, sym_comment, sym_include, - [114129] = 5, - ACTIONS(373), 1, + [131246] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4176), 1, + ACTIONS(5042), 1, anon_sym_COLON, - STATE(3064), 2, + STATE(3563), 2, sym_comment, sym_include, - [114146] = 5, - ACTIONS(373), 1, + [131263] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3870), 1, + ACTIONS(5044), 1, sym__terminator, - STATE(3065), 2, + STATE(3564), 2, sym_comment, sym_include, - [114163] = 5, - ACTIONS(373), 1, + [131280] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4178), 1, + ACTIONS(5046), 1, anon_sym_COLON, - STATE(3066), 2, + STATE(3565), 2, sym_comment, sym_include, - [114180] = 5, - ACTIONS(373), 1, + [131297] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3513), 1, + ACTIONS(3945), 1, anon_sym_COLON, - STATE(3067), 2, + STATE(3566), 2, sym_comment, sym_include, - [114197] = 5, - ACTIONS(373), 1, + [131314] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4180), 1, + ACTIONS(2839), 1, anon_sym_COLON, - STATE(3068), 2, + STATE(3567), 2, sym_comment, sym_include, - [114214] = 5, - ACTIONS(373), 1, + [131331] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4182), 1, - anon_sym_COLON, - STATE(3069), 2, + ACTIONS(5048), 1, + anon_sym_DOT, + STATE(3568), 2, sym_comment, sym_include, - [114231] = 5, - ACTIONS(373), 1, + [131348] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4184), 1, - anon_sym_COLON, - STATE(3070), 2, + ACTIONS(5050), 1, + aux_sym__block_terminator_token1, + STATE(3569), 2, sym_comment, sym_include, - [114248] = 5, - ACTIONS(373), 1, + [131365] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4186), 1, - anon_sym_COLON, - STATE(3071), 2, + ACTIONS(4141), 1, + sym__terminator, + STATE(3570), 2, + sym_comment, + sym_include, + [131382] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5052), 1, + sym__terminator, + STATE(3571), 2, sym_comment, sym_include, - [114265] = 5, - ACTIONS(373), 1, + [131399] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4188), 1, + ACTIONS(5054), 1, anon_sym_COLON, - STATE(3072), 2, + STATE(3572), 2, sym_comment, sym_include, - [114282] = 5, - ACTIONS(373), 1, + [131416] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4190), 1, - sym__terminator, - STATE(3073), 2, + ACTIONS(5056), 1, + sym_identifier, + STATE(3573), 2, sym_comment, sym_include, - [114299] = 5, - ACTIONS(373), 1, + [131433] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4192), 1, + ACTIONS(5058), 1, sym__terminator, - STATE(3074), 2, + STATE(3574), 2, sym_comment, sym_include, - [114316] = 5, - ACTIONS(373), 1, + [131450] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3505), 1, - anon_sym_COLON, - STATE(3075), 2, + ACTIONS(5060), 1, + sym_identifier, + STATE(3575), 2, sym_comment, sym_include, - [114333] = 5, - ACTIONS(373), 1, + [131467] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4194), 1, - aux_sym__block_terminator_token1, - STATE(3076), 2, + ACTIONS(5062), 1, + sym_identifier, + STATE(3576), 2, sym_comment, sym_include, - [114350] = 5, - ACTIONS(373), 1, + [131484] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4196), 1, + ACTIONS(5064), 1, sym__terminator, - STATE(3077), 2, + STATE(3577), 2, + sym_comment, + sym_include, + [131501] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5066), 1, + aux_sym_buffer_definition_token2, + STATE(3578), 2, sym_comment, sym_include, - [114367] = 5, - ACTIONS(373), 1, + [131518] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4198), 1, + ACTIONS(4508), 1, sym__terminator, - STATE(3078), 2, + STATE(3579), 2, + sym_comment, + sym_include, + [131535] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5068), 1, + anon_sym_COLON, + STATE(3580), 2, sym_comment, sym_include, - [114384] = 5, - ACTIONS(373), 1, + [131552] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4200), 1, + ACTIONS(5070), 1, + anon_sym_COLON, + STATE(3581), 2, + sym_comment, + sym_include, + [131569] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(4516), 1, sym__terminator, - STATE(3079), 2, + STATE(3582), 2, sym_comment, sym_include, - [114401] = 5, - ACTIONS(373), 1, + [131586] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4202), 1, + ACTIONS(5072), 1, anon_sym_COLON, - STATE(3080), 2, + STATE(3583), 2, sym_comment, sym_include, - [114418] = 5, - ACTIONS(3), 1, + [131603] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4204), 1, - sym_identifier, - STATE(3081), 2, + ACTIONS(5074), 1, + anon_sym_COLON, + STATE(3584), 2, + sym_comment, + sym_include, + [131620] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3357), 1, + anon_sym_COLON, + STATE(3585), 2, sym_comment, sym_include, - [114435] = 5, - ACTIONS(373), 1, + [131637] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4206), 1, - anon_sym_COLON, - STATE(3082), 2, + ACTIONS(5076), 1, + sym_identifier, + STATE(3586), 2, sym_comment, sym_include, - [114452] = 5, - ACTIONS(373), 1, + [131654] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4208), 1, - aux_sym__block_terminator_token1, - STATE(3083), 2, + ACTIONS(5078), 1, + aux_sym_input_expression_token2, + STATE(3587), 2, sym_comment, sym_include, - [114469] = 5, - ACTIONS(373), 1, + [131671] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4210), 1, - anon_sym_COLON, - STATE(3084), 2, + ACTIONS(5080), 1, + anon_sym_RBRACE, + STATE(3588), 2, sym_comment, sym_include, - [114486] = 5, - ACTIONS(373), 1, + [131688] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4212), 1, - aux_sym__block_terminator_token1, - STATE(3085), 2, + ACTIONS(3343), 1, + anon_sym_COLON, + STATE(3589), 2, sym_comment, sym_include, - [114503] = 5, - ACTIONS(373), 1, + [131705] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4214), 1, + ACTIONS(4494), 1, sym__terminator, - STATE(3086), 2, + STATE(3590), 2, sym_comment, sym_include, - [114520] = 5, - ACTIONS(373), 1, + [131722] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3846), 1, - sym__terminator, - STATE(3087), 2, + ACTIONS(5082), 1, + sym_identifier, + STATE(3591), 2, sym_comment, sym_include, - [114537] = 5, - ACTIONS(373), 1, + [131739] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3850), 1, - sym__terminator, - STATE(3088), 2, + ACTIONS(5084), 1, + aux_sym__block_terminator_token1, + STATE(3592), 2, sym_comment, sym_include, - [114554] = 5, - ACTIONS(373), 1, + [131756] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4216), 1, - anon_sym_DOT, - STATE(3089), 2, + ACTIONS(5086), 1, + aux_sym__block_terminator_token1, + STATE(3593), 2, sym_comment, sym_include, - [114571] = 5, - ACTIONS(373), 1, + [131773] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4218), 1, + ACTIONS(5088), 1, sym__terminator, - STATE(3090), 2, + STATE(3594), 2, sym_comment, sym_include, - [114588] = 5, - ACTIONS(373), 1, + [131790] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4220), 1, - sym__terminator, - STATE(3091), 2, + ACTIONS(5090), 1, + anon_sym_COLON, + STATE(3595), 2, sym_comment, sym_include, - [114605] = 5, - ACTIONS(373), 1, + [131807] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4222), 1, + ACTIONS(5092), 1, anon_sym_COLON, - STATE(3092), 2, + STATE(3596), 2, sym_comment, sym_include, - [114622] = 5, - ACTIONS(373), 1, + [131824] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4224), 1, + ACTIONS(5094), 1, anon_sym_COLON, - STATE(3093), 2, + STATE(3597), 2, sym_comment, sym_include, - [114639] = 5, - ACTIONS(373), 1, + [131841] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4226), 1, + ACTIONS(5096), 1, anon_sym_COLON, - STATE(3094), 2, + STATE(3598), 2, sym_comment, sym_include, - [114656] = 5, - ACTIONS(373), 1, + [131858] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4228), 1, - anon_sym_COLON, - STATE(3095), 2, + ACTIONS(4250), 1, + anon_sym_DOT, + STATE(3599), 2, sym_comment, sym_include, - [114673] = 5, - ACTIONS(373), 1, + [131875] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4230), 1, - anon_sym_COLON, - STATE(3096), 2, + ACTIONS(5098), 1, + anon_sym_COMMA, + STATE(3600), 2, sym_comment, sym_include, - [114690] = 5, - ACTIONS(373), 1, + [131892] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4232), 1, + ACTIONS(3935), 1, anon_sym_COLON, - STATE(3097), 2, + STATE(3601), 2, sym_comment, sym_include, - [114707] = 5, - ACTIONS(373), 1, + [131909] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4234), 1, + ACTIONS(5100), 1, anon_sym_COMMA, - STATE(3098), 2, + STATE(3602), 2, sym_comment, sym_include, - [114724] = 5, - ACTIONS(373), 1, + [131926] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3321), 1, - anon_sym_COLON, - STATE(3099), 2, + ACTIONS(5102), 1, + sym__terminator, + STATE(3603), 2, sym_comment, sym_include, - [114741] = 5, - ACTIONS(373), 1, + [131943] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4236), 1, - anon_sym_COMMA, - STATE(3100), 2, + ACTIONS(5104), 1, + sym_identifier, + STATE(3604), 2, sym_comment, sym_include, - [114758] = 5, - ACTIONS(373), 1, + [131960] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4238), 1, - anon_sym_COLON, - STATE(3101), 2, + ACTIONS(4478), 1, + sym__terminator, + STATE(3605), 2, sym_comment, sym_include, - [114775] = 5, - ACTIONS(373), 1, + [131977] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4240), 1, + ACTIONS(3943), 1, sym__terminator, - STATE(3102), 2, + STATE(3606), 2, sym_comment, sym_include, - [114792] = 5, - ACTIONS(373), 1, + [131994] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4242), 1, - anon_sym_COLON, - STATE(3103), 2, + ACTIONS(5106), 1, + sym__terminator, + STATE(3607), 2, sym_comment, sym_include, - [114809] = 5, - ACTIONS(373), 1, + [132011] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4244), 1, + ACTIONS(5108), 1, sym__terminator, - STATE(3104), 2, + STATE(3608), 2, sym_comment, sym_include, - [114826] = 5, - ACTIONS(3), 1, + [132028] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4246), 1, - sym_identifier, - STATE(3105), 2, + ACTIONS(5110), 1, + anon_sym_LPAREN, + STATE(3609), 2, + sym_comment, + sym_include, + [132045] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5112), 1, + aux_sym__block_terminator_token1, + STATE(3610), 2, sym_comment, sym_include, - [114843] = 5, + [132062] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4248), 1, + ACTIONS(5114), 1, sym_identifier, - STATE(3106), 2, + STATE(3611), 2, sym_comment, sym_include, - [114860] = 5, + [132079] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4250), 1, + ACTIONS(2052), 1, sym_identifier, - STATE(3107), 2, + STATE(3612), 2, sym_comment, sym_include, - [114877] = 5, - ACTIONS(373), 1, + [132096] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4252), 1, - sym__terminator, - STATE(3108), 2, + ACTIONS(5116), 1, + anon_sym_RPAREN, + STATE(3613), 2, sym_comment, sym_include, - [114894] = 5, - ACTIONS(373), 1, + [132113] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3280), 1, + ACTIONS(5118), 1, sym__terminator, - STATE(3109), 2, + STATE(3614), 2, sym_comment, sym_include, - [114911] = 5, - ACTIONS(373), 1, + [132130] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4254), 1, - anon_sym_RPAREN, - STATE(3110), 2, + ACTIONS(5120), 1, + anon_sym_COLON, + STATE(3615), 2, sym_comment, sym_include, - [114928] = 5, - ACTIONS(373), 1, + [132147] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4256), 1, + ACTIONS(5122), 1, anon_sym_COLON, - STATE(3111), 2, + STATE(3616), 2, sym_comment, sym_include, - [114945] = 5, - ACTIONS(373), 1, + [132164] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4258), 1, - anon_sym_DOT, - STATE(3112), 2, + ACTIONS(5124), 1, + aux_sym_buffer_definition_token2, + STATE(3617), 2, sym_comment, sym_include, - [114962] = 5, - ACTIONS(373), 1, + [132181] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4260), 1, - anon_sym_RPAREN, - STATE(3113), 2, + ACTIONS(5126), 1, + sym_identifier, + STATE(3618), 2, sym_comment, sym_include, - [114979] = 5, - ACTIONS(373), 1, + [132198] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4262), 1, - anon_sym_RBRACE, - STATE(3114), 2, + ACTIONS(5128), 1, + sym__integer_literal, + STATE(3619), 2, sym_comment, sym_include, - [114996] = 5, - ACTIONS(373), 1, + [132215] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4264), 1, - anon_sym_COLON, - STATE(3115), 2, + ACTIONS(5130), 1, + sym_identifier, + STATE(3620), 2, sym_comment, sym_include, - [115013] = 5, - ACTIONS(373), 1, + [132232] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4266), 1, - anon_sym_RPAREN, - STATE(3116), 2, + ACTIONS(5132), 1, + aux_sym__block_terminator_token1, + STATE(3621), 2, sym_comment, sym_include, - [115030] = 5, - ACTIONS(373), 1, + [132249] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3818), 1, + ACTIONS(5134), 1, sym__terminator, - STATE(3117), 2, - sym_comment, - sym_include, - [115047] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3282), 1, - anon_sym_COLON, - STATE(3118), 2, - sym_comment, - sym_include, - [115064] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(3215), 1, - anon_sym_COLON, - STATE(3119), 2, + STATE(3622), 2, sym_comment, sym_include, - [115081] = 5, - ACTIONS(373), 1, + [132266] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4268), 1, - anon_sym_COLON, - STATE(3120), 2, + ACTIONS(5136), 1, + aux_sym_buffer_definition_token2, + STATE(3623), 2, sym_comment, sym_include, - [115098] = 5, - ACTIONS(373), 1, + [132283] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4270), 1, + ACTIONS(4466), 1, sym__terminator, - STATE(3121), 2, + STATE(3624), 2, sym_comment, sym_include, - [115115] = 5, - ACTIONS(373), 1, + [132300] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4272), 1, + ACTIONS(4460), 1, sym__terminator, - STATE(3122), 2, + STATE(3625), 2, sym_comment, sym_include, - [115132] = 5, - ACTIONS(373), 1, + [132317] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3288), 1, - anon_sym_LPAREN, - STATE(3123), 2, + ACTIONS(5138), 1, + anon_sym_COLON, + STATE(3626), 2, sym_comment, sym_include, - [115149] = 5, + [132334] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4274), 1, + ACTIONS(5140), 1, sym_identifier, - STATE(3124), 2, + STATE(3627), 2, sym_comment, sym_include, - [115166] = 5, - ACTIONS(373), 1, + [132351] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4276), 1, - anon_sym_COLON, - STATE(3125), 2, + ACTIONS(5142), 1, + anon_sym_LPAREN, + STATE(3628), 2, sym_comment, sym_include, - [115183] = 5, - ACTIONS(373), 1, + [132368] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4278), 1, - aux_sym_of_token1, - STATE(3126), 2, + ACTIONS(5144), 1, + sym_identifier, + STATE(3629), 2, sym_comment, sym_include, - [115200] = 5, - ACTIONS(373), 1, + [132385] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4280), 1, - aux_sym__block_terminator_token1, - STATE(3127), 2, + ACTIONS(5146), 1, + sym__terminator, + STATE(3630), 2, sym_comment, sym_include, - [115217] = 5, - ACTIONS(373), 1, + [132402] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2643), 1, - anon_sym_COLON, - STATE(3128), 2, + ACTIONS(5148), 1, + aux_sym_sort_clause_token2, + STATE(3631), 2, sym_comment, sym_include, - [115234] = 5, - ACTIONS(373), 1, + [132419] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4282), 1, - anon_sym_LPAREN, - STATE(3129), 2, + ACTIONS(5150), 1, + anon_sym_RBRACE, + STATE(3632), 2, sym_comment, sym_include, - [115251] = 5, - ACTIONS(373), 1, + [132436] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4284), 1, - sym__terminator, - STATE(3130), 2, + ACTIONS(5152), 1, + aux_sym__block_terminator_token1, + STATE(3633), 2, sym_comment, sym_include, - [115268] = 5, - ACTIONS(373), 1, + [132453] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4286), 1, + ACTIONS(5154), 1, sym__terminator, - STATE(3131), 2, - sym_comment, - sym_include, - [115285] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4288), 1, - anon_sym_RBRACE, - STATE(3132), 2, - sym_comment, - sym_include, - [115302] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(5), 1, - anon_sym_SLASH_STAR, - ACTIONS(7), 1, - anon_sym_LBRACE, - ACTIONS(4290), 1, - sym_identifier, - STATE(3133), 2, + STATE(3634), 2, sym_comment, sym_include, - [115319] = 5, - ACTIONS(373), 1, + [132470] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4292), 1, - sym__integer_literal, - STATE(3134), 2, + ACTIONS(2770), 1, + aux_sym__block_terminator_token1, + STATE(3635), 2, sym_comment, sym_include, - [115336] = 5, - ACTIONS(373), 1, + [132487] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3244), 1, - anon_sym_COLON, - STATE(3135), 2, + ACTIONS(5156), 1, + aux_sym_of_token1, + STATE(3636), 2, sym_comment, sym_include, - [115353] = 5, - ACTIONS(373), 1, + [132504] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4294), 1, - anon_sym_RPAREN, - STATE(3136), 2, + ACTIONS(5158), 1, + sym__terminator, + STATE(3637), 2, sym_comment, sym_include, - [115370] = 5, - ACTIONS(373), 1, + [132521] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4296), 1, + ACTIONS(2804), 1, anon_sym_COLON, - STATE(3137), 2, + STATE(3638), 2, sym_comment, sym_include, - [115387] = 5, - ACTIONS(373), 1, + [132538] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4298), 1, + ACTIONS(4151), 1, anon_sym_COLON, - STATE(3138), 2, + STATE(3639), 2, sym_comment, sym_include, - [115404] = 5, - ACTIONS(373), 1, + [132555] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4300), 1, - anon_sym_DOT, - STATE(3139), 2, + ACTIONS(5160), 1, + aux_sym_property_definition_token1, + STATE(3640), 2, sym_comment, sym_include, - [115421] = 5, - ACTIONS(373), 1, + [132572] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4302), 1, - anon_sym_RBRACE, - STATE(3140), 2, + ACTIONS(5162), 1, + anon_sym_RPAREN, + STATE(3641), 2, sym_comment, sym_include, - [115438] = 5, - ACTIONS(373), 1, + [132589] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4304), 1, - anon_sym_RPAREN, - STATE(3141), 2, + ACTIONS(5164), 1, + anon_sym_COLON, + STATE(3642), 2, sym_comment, sym_include, - [115455] = 5, - ACTIONS(373), 1, + [132606] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4306), 1, - aux_sym__block_terminator_token1, - STATE(3142), 2, + ACTIONS(5166), 1, + sym__terminator, + STATE(3643), 2, sym_comment, sym_include, - [115472] = 5, - ACTIONS(373), 1, + [132623] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4308), 1, + ACTIONS(5168), 1, sym__terminator, - STATE(3143), 2, + STATE(3644), 2, sym_comment, sym_include, - [115489] = 5, - ACTIONS(373), 1, + [132640] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4310), 1, - sym__terminator, - STATE(3144), 2, + ACTIONS(5170), 1, + anon_sym_COLON, + STATE(3645), 2, sym_comment, sym_include, - [115506] = 5, - ACTIONS(373), 1, + [132657] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4312), 1, - aux_sym_buffer_definition_token2, - STATE(3145), 2, + ACTIONS(5172), 1, + sym__terminator, + STATE(3646), 2, sym_comment, sym_include, - [115523] = 5, - ACTIONS(373), 1, + [132674] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4314), 1, - aux_sym_sort_clause_token2, - STATE(3146), 2, + ACTIONS(5174), 1, + sym__terminator, + STATE(3647), 2, sym_comment, sym_include, - [115540] = 5, - ACTIONS(373), 1, + [132691] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4316), 1, - aux_sym_buffer_definition_token2, - STATE(3147), 2, + ACTIONS(5176), 1, + anon_sym_RPAREN, + STATE(3648), 2, sym_comment, sym_include, - [115557] = 5, - ACTIONS(373), 1, + [132708] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4318), 1, - aux_sym_buffer_definition_token2, - STATE(3148), 2, + ACTIONS(4163), 1, + anon_sym_LPAREN, + STATE(3649), 2, sym_comment, sym_include, - [115574] = 5, - ACTIONS(373), 1, + [132725] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4320), 1, - aux_sym__block_terminator_token1, - STATE(3149), 2, + ACTIONS(5178), 1, + sym__terminator, + STATE(3650), 2, sym_comment, sym_include, - [115591] = 5, - ACTIONS(3), 1, + [132742] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4322), 1, - sym_identifier, - STATE(3150), 2, + ACTIONS(5180), 1, + sym__terminator, + STATE(3651), 2, sym_comment, sym_include, - [115608] = 5, - ACTIONS(3), 1, + [132759] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4324), 1, - sym_identifier, - STATE(3151), 2, + ACTIONS(5182), 1, + anon_sym_EQ, + STATE(3652), 2, sym_comment, sym_include, - [115625] = 5, + [132776] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4326), 1, + ACTIONS(5184), 1, sym_identifier, - STATE(3152), 2, + STATE(3653), 2, sym_comment, sym_include, - [115642] = 5, - ACTIONS(373), 1, + [132793] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4328), 1, - anon_sym_COLON, - STATE(3153), 2, + ACTIONS(5186), 1, + anon_sym_RBRACE, + STATE(3654), 2, sym_comment, sym_include, - [115659] = 5, - ACTIONS(373), 1, + [132810] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4330), 1, - anon_sym_COLON, - STATE(3154), 2, + ACTIONS(5188), 1, + sym__terminator, + STATE(3655), 2, sym_comment, sym_include, - [115676] = 5, + [132827] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4332), 1, + ACTIONS(5190), 1, sym_identifier, - STATE(3155), 2, - sym_comment, - sym_include, - [115693] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4334), 1, - aux_sym_variable_definition_token5, - STATE(3156), 2, + STATE(3656), 2, sym_comment, sym_include, - [115710] = 5, - ACTIONS(373), 1, + [132844] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4336), 1, - sym__terminator, - STATE(3157), 2, + ACTIONS(5192), 1, + sym_identifier, + STATE(3657), 2, sym_comment, sym_include, - [115727] = 5, - ACTIONS(373), 1, + [132861] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4338), 1, - sym__terminator, - STATE(3158), 2, + ACTIONS(5194), 1, + anon_sym_DOT, + STATE(3658), 2, sym_comment, sym_include, - [115744] = 5, - ACTIONS(373), 1, + [132878] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4340), 1, - anon_sym_COLON, - STATE(3159), 2, + ACTIONS(5196), 1, + anon_sym_RPAREN, + STATE(3659), 2, sym_comment, sym_include, - [115761] = 5, - ACTIONS(373), 1, + [132895] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4342), 1, - anon_sym_RBRACE, - STATE(3160), 2, + ACTIONS(5198), 1, + anon_sym_RPAREN, + STATE(3660), 2, sym_comment, sym_include, - [115778] = 5, - ACTIONS(373), 1, + [132912] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4344), 1, + ACTIONS(5200), 1, sym__terminator, - STATE(3161), 2, + STATE(3661), 2, sym_comment, sym_include, - [115795] = 5, - ACTIONS(373), 1, + [132929] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4346), 1, - sym__terminator, - STATE(3162), 2, + ACTIONS(5202), 1, + sym__integer_literal, + STATE(3662), 2, sym_comment, sym_include, - [115812] = 5, - ACTIONS(373), 1, + [132946] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4348), 1, - anon_sym_RBRACE, - STATE(3163), 2, + ACTIONS(5204), 1, + sym_identifier, + STATE(3663), 2, sym_comment, sym_include, - [115829] = 5, - ACTIONS(373), 1, + [132963] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3325), 1, - anon_sym_LPAREN, - STATE(3164), 2, + ACTIONS(5206), 1, + sym_identifier, + STATE(3664), 2, sym_comment, sym_include, - [115846] = 5, - ACTIONS(373), 1, + [132980] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4350), 1, - anon_sym_EQ, - STATE(3165), 2, + ACTIONS(5208), 1, + anon_sym_RBRACE, + STATE(3665), 2, sym_comment, sym_include, - [115863] = 5, - ACTIONS(373), 1, + [132997] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4352), 1, - anon_sym_COLON, - STATE(3166), 2, + ACTIONS(5210), 1, + aux_sym__block_terminator_token1, + STATE(3666), 2, sym_comment, sym_include, - [115880] = 5, - ACTIONS(373), 1, + [133014] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4354), 1, - aux_sym_do_statement_token1, - STATE(3167), 2, + ACTIONS(5212), 1, + aux_sym_procedure_parameter_definition_token2, + STATE(3667), 2, sym_comment, sym_include, - [115897] = 5, + [133031] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4356), 1, + ACTIONS(5214), 1, sym_identifier, - STATE(3168), 2, - sym_comment, - sym_include, - [115914] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4358), 1, - anon_sym_RBRACE, - STATE(3169), 2, + STATE(3668), 2, sym_comment, sym_include, - [115931] = 5, + [133048] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4360), 1, + ACTIONS(5216), 1, sym_identifier, - STATE(3170), 2, + STATE(3669), 2, sym_comment, sym_include, - [115948] = 5, - ACTIONS(373), 1, + [133065] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4362), 1, + ACTIONS(5218), 1, anon_sym_COLON, - STATE(3171), 2, + STATE(3670), 2, sym_comment, sym_include, - [115965] = 5, - ACTIONS(373), 1, + [133082] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4364), 1, - aux_sym__block_terminator_token1, - STATE(3172), 2, + ACTIONS(3904), 1, + anon_sym_LPAREN, + STATE(3671), 2, sym_comment, sym_include, - [115982] = 5, - ACTIONS(373), 1, + [133099] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4366), 1, - anon_sym_LPAREN, - STATE(3173), 2, + ACTIONS(5220), 1, + aux_sym__block_terminator_token1, + STATE(3672), 2, sym_comment, sym_include, - [115999] = 5, - ACTIONS(3), 1, + [133116] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4368), 1, - sym_identifier, - STATE(3174), 2, + ACTIONS(5222), 1, + sym__terminator, + STATE(3673), 2, sym_comment, sym_include, - [116016] = 5, - ACTIONS(3), 1, + [133133] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4370), 1, - sym_identifier, - STATE(3175), 2, + ACTIONS(3177), 1, + anon_sym_COLON, + STATE(3674), 2, sym_comment, sym_include, - [116033] = 5, - ACTIONS(373), 1, + [133150] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4372), 1, - aux_sym__block_terminator_token1, - STATE(3176), 2, + ACTIONS(5224), 1, + sym__terminator, + STATE(3675), 2, sym_comment, sym_include, - [116050] = 5, - ACTIONS(373), 1, + [133167] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4374), 1, - anon_sym_COLON, - STATE(3177), 2, + ACTIONS(4546), 1, + aux_sym_primitive_type_token1, + STATE(3676), 2, sym_comment, sym_include, - [116067] = 5, + [133184] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4376), 1, + ACTIONS(5226), 1, sym_identifier, - STATE(3178), 2, + STATE(3677), 2, sym_comment, sym_include, - [116084] = 5, - ACTIONS(3), 1, + [133201] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4378), 1, - sym_identifier, - STATE(3179), 2, + ACTIONS(2819), 1, + anon_sym_COLON, + STATE(3678), 2, sym_comment, sym_include, - [116101] = 5, - ACTIONS(373), 1, + [133218] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4380), 1, - aux_sym__block_terminator_token1, - STATE(3180), 2, + ACTIONS(3882), 1, + anon_sym_LPAREN, + STATE(3679), 2, sym_comment, sym_include, - [116118] = 5, - ACTIONS(373), 1, + [133235] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4382), 1, - anon_sym_COMMA, - STATE(3181), 2, + ACTIONS(3595), 1, + anon_sym_COLON, + STATE(3680), 2, sym_comment, sym_include, - [116135] = 5, - ACTIONS(373), 1, + [133252] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4384), 1, - sym__terminator, - STATE(3182), 2, + ACTIONS(5228), 1, + anon_sym_COLON, + STATE(3681), 2, sym_comment, sym_include, - [116152] = 5, - ACTIONS(373), 1, + [133269] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4386), 1, - anon_sym_COMMA, - STATE(3183), 2, + ACTIONS(5230), 1, + sym_identifier, + STATE(3682), 2, sym_comment, sym_include, - [116169] = 5, - ACTIONS(373), 1, + [133286] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4388), 1, - anon_sym_COMMA, - STATE(3184), 2, + ACTIONS(5232), 1, + anon_sym_COLON, + STATE(3683), 2, sym_comment, sym_include, - [116186] = 5, + [133303] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4390), 1, - sym_identifier, - STATE(3185), 2, + ACTIONS(5234), 1, + aux_sym_comment_token1, + STATE(3684), 2, sym_comment, sym_include, - [116203] = 5, + [133320] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4392), 1, + ACTIONS(5236), 1, sym_identifier, - STATE(3186), 2, - sym_comment, - sym_include, - [116220] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4394), 1, - sym__integer_literal, - STATE(3187), 2, + STATE(3685), 2, sym_comment, sym_include, - [116237] = 5, - ACTIONS(373), 1, + [133337] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4396), 1, - aux_sym_buffer_definition_token2, - STATE(3188), 2, + ACTIONS(5238), 1, + sym_identifier, + STATE(3686), 2, sym_comment, sym_include, - [116254] = 5, - ACTIONS(373), 1, + [133354] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4398), 1, - aux_sym_buffer_definition_token2, - STATE(3189), 2, + ACTIONS(5240), 1, + anon_sym_COLON, + STATE(3687), 2, sym_comment, sym_include, - [116271] = 5, - ACTIONS(373), 1, + [133371] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4400), 1, - aux_sym_on_error_phrase_token3, - STATE(3190), 2, + ACTIONS(5242), 1, + sym__terminator, + STATE(3688), 2, sym_comment, sym_include, - [116288] = 5, - ACTIONS(373), 1, + [133388] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4402), 1, - anon_sym_DOT, - STATE(3191), 2, + ACTIONS(5244), 1, + anon_sym_LPAREN, + STATE(3689), 2, sym_comment, sym_include, - [116305] = 5, - ACTIONS(373), 1, + [133405] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3072), 1, - aux_sym_of_token1, - STATE(3192), 2, + ACTIONS(5246), 1, + sym_identifier, + STATE(3690), 2, sym_comment, sym_include, - [116322] = 5, - ACTIONS(373), 1, + [133422] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3096), 1, - aux_sym_of_token1, - STATE(3193), 2, + ACTIONS(5248), 1, + sym_identifier, + STATE(3691), 2, sym_comment, sym_include, - [116339] = 5, - ACTIONS(373), 1, + [133439] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4404), 1, - anon_sym_COLON, - STATE(3194), 2, + ACTIONS(5250), 1, + sym_identifier, + STATE(3692), 2, sym_comment, sym_include, - [116356] = 5, - ACTIONS(373), 1, + [133456] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4406), 1, - anon_sym_RBRACE, - STATE(3195), 2, + ACTIONS(4183), 1, + anon_sym_LPAREN, + STATE(3693), 2, sym_comment, sym_include, - [116373] = 5, - ACTIONS(373), 1, + [133473] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(3388), 1, - aux_sym_on_stop_phrase_token1, - STATE(3196), 2, + ACTIONS(5252), 1, + sym_identifier, + STATE(3694), 2, sym_comment, sym_include, - [116390] = 5, + [133490] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4408), 1, + ACTIONS(5254), 1, sym_identifier, - STATE(3197), 2, + STATE(3695), 2, sym_comment, sym_include, - [116407] = 5, - ACTIONS(373), 1, + [133507] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4410), 1, - aux_sym_variable_definition_token5, - STATE(3198), 2, + ACTIONS(5256), 1, + anon_sym_COLON, + STATE(3696), 2, sym_comment, sym_include, - [116424] = 5, + [133524] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4412), 1, + ACTIONS(5258), 1, sym_identifier, - STATE(3199), 2, - sym_comment, - sym_include, - [116441] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4414), 1, - aux_sym_buffer_definition_token2, - STATE(3200), 2, + STATE(3697), 2, sym_comment, sym_include, - [116458] = 5, - ACTIONS(373), 1, + [133541] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4416), 1, - aux_sym_buffer_definition_token2, - STATE(3201), 2, + ACTIONS(5260), 1, + anon_sym_EQ, + STATE(3698), 2, sym_comment, sym_include, - [116475] = 5, - ACTIONS(373), 1, + [133558] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4418), 1, - anon_sym_RPAREN, - STATE(3202), 2, + ACTIONS(5262), 1, + sym_identifier, + STATE(3699), 2, sym_comment, sym_include, - [116492] = 5, - ACTIONS(373), 1, + [133575] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4420), 1, - aux_sym_of_token1, - STATE(3203), 2, + ACTIONS(3989), 1, + anon_sym_COLON, + STATE(3700), 2, sym_comment, sym_include, - [116509] = 5, - ACTIONS(373), 1, + [133592] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3128), 1, - anon_sym_COLON, - STATE(3204), 2, + ACTIONS(5264), 1, + sym__terminator, + STATE(3701), 2, sym_comment, sym_include, - [116526] = 5, - ACTIONS(373), 1, + [133609] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3429), 1, - anon_sym_COLON, - STATE(3205), 2, + ACTIONS(5266), 1, + anon_sym_COMMA, + STATE(3702), 2, sym_comment, sym_include, - [116543] = 5, - ACTIONS(373), 1, + [133626] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4422), 1, - anon_sym_COLON, - STATE(3206), 2, + ACTIONS(5268), 1, + sym_identifier, + STATE(3703), 2, sym_comment, sym_include, - [116560] = 5, - ACTIONS(373), 1, + [133643] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4424), 1, + ACTIONS(5270), 1, anon_sym_COLON, - STATE(3207), 2, + STATE(3704), 2, sym_comment, sym_include, - [116577] = 5, - ACTIONS(373), 1, + [133660] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4426), 1, - aux_sym__block_terminator_token1, - STATE(3208), 2, + ACTIONS(5272), 1, + aux_sym_buffer_definition_token2, + STATE(3705), 2, sym_comment, sym_include, - [116594] = 5, - ACTIONS(373), 1, + [133677] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3335), 1, - anon_sym_COLON, - STATE(3209), 2, + ACTIONS(5274), 1, + aux_sym_buffer_definition_token2, + STATE(3706), 2, sym_comment, sym_include, - [116611] = 5, - ACTIONS(373), 1, + [133694] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4428), 1, + ACTIONS(5276), 1, aux_sym_on_error_phrase_token3, - STATE(3210), 2, + STATE(3707), 2, sym_comment, sym_include, - [116628] = 5, - ACTIONS(373), 1, + [133711] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3479), 1, + ACTIONS(5278), 1, anon_sym_COLON, - STATE(3211), 2, + STATE(3708), 2, sym_comment, sym_include, - [116645] = 5, - ACTIONS(373), 1, + [133728] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4430), 1, - anon_sym_LPAREN, - STATE(3212), 2, + ACTIONS(5280), 1, + sym_identifier, + STATE(3709), 2, sym_comment, sym_include, - [116662] = 5, - ACTIONS(373), 1, + [133745] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4432), 1, - anon_sym_COLON, - STATE(3213), 2, + ACTIONS(3758), 1, + aux_sym_of_token1, + STATE(3710), 2, sym_comment, sym_include, - [116679] = 5, - ACTIONS(373), 1, + [133762] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4434), 1, - aux_sym_on_error_phrase_token3, - STATE(3214), 2, + ACTIONS(5282), 1, + anon_sym_LPAREN, + STATE(3711), 2, sym_comment, sym_include, - [116696] = 5, - ACTIONS(373), 1, + [133779] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4436), 1, - anon_sym_COLON, - STATE(3215), 2, + ACTIONS(5284), 1, + sym_identifier, + STATE(3712), 2, sym_comment, sym_include, - [116713] = 5, + [133796] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4438), 1, + ACTIONS(5286), 1, sym_identifier, - STATE(3216), 2, + STATE(3713), 2, sym_comment, sym_include, - [116730] = 5, - ACTIONS(3), 1, + [133813] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4440), 1, - sym_identifier, - STATE(3217), 2, + ACTIONS(2827), 1, + anon_sym_COLON, + STATE(3714), 2, sym_comment, sym_include, - [116747] = 5, - ACTIONS(373), 1, + [133830] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4442), 1, - anon_sym_LPAREN, - STATE(3218), 2, + ACTIONS(5288), 1, + aux_sym_variable_definition_token5, + STATE(3715), 2, sym_comment, sym_include, - [116764] = 5, - ACTIONS(373), 1, + [133847] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4444), 1, + ACTIONS(5290), 1, anon_sym_COLON, - STATE(3219), 2, + STATE(3716), 2, sym_comment, sym_include, - [116781] = 5, - ACTIONS(373), 1, + [133864] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4446), 1, - aux_sym__block_terminator_token1, - STATE(3220), 2, + ACTIONS(5292), 1, + aux_sym_buffer_definition_token2, + STATE(3717), 2, sym_comment, sym_include, - [116798] = 5, - ACTIONS(373), 1, + [133881] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4448), 1, - anon_sym_COLON, - STATE(3221), 2, + ACTIONS(5294), 1, + aux_sym_buffer_definition_token2, + STATE(3718), 2, sym_comment, sym_include, - [116815] = 5, - ACTIONS(373), 1, + [133898] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3037), 1, + ACTIONS(3129), 1, anon_sym_COLON, - STATE(3222), 2, + STATE(3719), 2, sym_comment, sym_include, - [116832] = 5, - ACTIONS(373), 1, + [133915] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4450), 1, - anon_sym_LPAREN, - STATE(3223), 2, + ACTIONS(5296), 1, + aux_sym_of_token1, + STATE(3720), 2, sym_comment, sym_include, - [116849] = 5, - ACTIONS(373), 1, + [133932] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4452), 1, + ACTIONS(5298), 1, + aux_sym_primitive_type_token1, + STATE(3721), 2, + sym_comment, + sym_include, + [133949] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(3858), 1, anon_sym_COLON, - STATE(3224), 2, + STATE(3722), 2, sym_comment, sym_include, - [116866] = 5, - ACTIONS(373), 1, + [133966] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3794), 1, - anon_sym_DOT, - STATE(3225), 2, + ACTIONS(5300), 1, + anon_sym_COLON, + STATE(3723), 2, sym_comment, sym_include, - [116883] = 5, + [133983] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4454), 1, + ACTIONS(5302), 1, sym_identifier, - STATE(3226), 2, + STATE(3724), 2, sym_comment, sym_include, - [116900] = 5, - ACTIONS(373), 1, + [134000] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3539), 1, - anon_sym_LPAREN, - STATE(3227), 2, + ACTIONS(3856), 1, + anon_sym_COLON, + STATE(3725), 2, + sym_comment, + sym_include, + [134017] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(2796), 1, + anon_sym_COLON, + STATE(3726), 2, sym_comment, sym_include, - [116917] = 5, + [134034] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4456), 1, + ACTIONS(5304), 1, sym_identifier, - STATE(3228), 2, + STATE(3727), 2, sym_comment, sym_include, - [116934] = 5, - ACTIONS(373), 1, + [134051] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4458), 1, - anon_sym_COLON, - STATE(3229), 2, + ACTIONS(5306), 1, + anon_sym_LPAREN, + STATE(3728), 2, sym_comment, sym_include, - [116951] = 5, - ACTIONS(3), 1, + [134068] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4460), 1, - sym_identifier, - STATE(3230), 2, + ACTIONS(5308), 1, + aux_sym_output_stream_statement_token1, + STATE(3729), 2, sym_comment, sym_include, - [116968] = 5, - ACTIONS(3), 1, + [134085] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4462), 1, - sym_identifier, - STATE(3231), 2, + ACTIONS(5310), 1, + sym__terminator, + STATE(3730), 2, sym_comment, sym_include, - [116985] = 5, - ACTIONS(3), 1, + [134102] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4464), 1, - sym_identifier, - STATE(3232), 2, + ACTIONS(5312), 1, + anon_sym_COLON, + STATE(3731), 2, sym_comment, sym_include, - [117002] = 5, + [134119] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4466), 1, + ACTIONS(5314), 1, sym_identifier, - STATE(3233), 2, + STATE(3732), 2, sym_comment, sym_include, - [117019] = 5, + [134136] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4468), 1, + ACTIONS(5316), 1, sym_identifier, - STATE(3234), 2, + STATE(3733), 2, sym_comment, sym_include, - [117036] = 5, - ACTIONS(3), 1, + [134153] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4470), 1, - sym_identifier, - STATE(3235), 2, + ACTIONS(5318), 1, + anon_sym_LPAREN, + STATE(3734), 2, sym_comment, sym_include, - [117053] = 5, - ACTIONS(373), 1, + [134170] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4472), 1, - aux_sym_do_statement_token1, - STATE(3236), 2, + ACTIONS(2792), 1, + anon_sym_COLON, + STATE(3735), 2, sym_comment, sym_include, - [117070] = 5, - ACTIONS(3), 1, + [134187] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4474), 1, - sym_identifier, - STATE(3237), 2, + ACTIONS(5320), 1, + anon_sym_LPAREN, + STATE(3736), 2, sym_comment, sym_include, - [117087] = 5, - ACTIONS(373), 1, + [134204] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4476), 1, - sym__terminator, - STATE(3238), 2, + ACTIONS(5322), 1, + anon_sym_RBRACE, + STATE(3737), 2, sym_comment, sym_include, - [117104] = 5, - ACTIONS(373), 1, + [134221] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4478), 1, - aux_sym_buffer_definition_token2, - STATE(3239), 2, + ACTIONS(5324), 1, + sym__terminator, + STATE(3738), 2, sym_comment, sym_include, - [117121] = 5, - ACTIONS(3), 1, + [134238] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4480), 1, - sym_identifier, - STATE(3240), 2, + ACTIONS(5326), 1, + anon_sym_LPAREN, + STATE(3739), 2, sym_comment, sym_include, - [117138] = 5, + [134255] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4482), 1, + ACTIONS(5328), 1, sym_identifier, - STATE(3241), 2, + STATE(3740), 2, sym_comment, sym_include, - [117155] = 5, - ACTIONS(3), 1, + [134272] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4484), 1, - sym_identifier, - STATE(3242), 2, + ACTIONS(5330), 1, + aux_sym_buffer_definition_token2, + STATE(3741), 2, sym_comment, sym_include, - [117172] = 5, + [134289] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4486), 1, + ACTIONS(5332), 1, sym_identifier, - STATE(3243), 2, - sym_comment, - sym_include, - [117189] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4488), 1, - sym__terminator, - STATE(3244), 2, + STATE(3742), 2, sym_comment, sym_include, - [117206] = 5, - ACTIONS(373), 1, + [134306] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4490), 1, - aux_sym_do_statement_token1, - STATE(3245), 2, + ACTIONS(5334), 1, + anon_sym_RPAREN, + STATE(3743), 2, sym_comment, sym_include, - [117223] = 5, - ACTIONS(373), 1, + [134323] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4492), 1, + ACTIONS(5336), 1, anon_sym_LPAREN, - STATE(3246), 2, + STATE(3744), 2, sym_comment, sym_include, - [117240] = 5, - ACTIONS(373), 1, + [134340] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4494), 1, - anon_sym_RBRACE, - STATE(3247), 2, + ACTIONS(5338), 1, + sym_identifier, + STATE(3745), 2, sym_comment, sym_include, - [117257] = 5, - ACTIONS(373), 1, + [134357] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4496), 1, - anon_sym_COLON, - STATE(3248), 2, + ACTIONS(5340), 1, + anon_sym_RPAREN, + STATE(3746), 2, sym_comment, sym_include, - [117274] = 5, + [134374] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4498), 1, + ACTIONS(5342), 1, sym_identifier, - STATE(3249), 2, + STATE(3747), 2, sym_comment, sym_include, - [117291] = 5, - ACTIONS(373), 1, + [134391] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4500), 1, - anon_sym_COLON, - STATE(3250), 2, + ACTIONS(5344), 1, + sym__terminator, + STATE(3748), 2, sym_comment, sym_include, - [117308] = 5, - ACTIONS(373), 1, + [134408] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4502), 1, - anon_sym_COLON, - STATE(3251), 2, + ACTIONS(5346), 1, + anon_sym_RPAREN, + STATE(3749), 2, sym_comment, sym_include, - [117325] = 5, - ACTIONS(373), 1, + [134425] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3353), 1, + ACTIONS(5348), 1, anon_sym_LPAREN, - STATE(3252), 2, + STATE(3750), 2, sym_comment, sym_include, - [117342] = 5, - ACTIONS(3), 1, + [134442] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4504), 1, - sym_identifier, - STATE(3253), 2, + ACTIONS(5350), 1, + anon_sym_RBRACE, + STATE(3751), 2, + sym_comment, + sym_include, + [134459] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5352), 1, + anon_sym_RPAREN, + STATE(3752), 2, sym_comment, sym_include, - [117359] = 5, + [134476] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4506), 1, + ACTIONS(5354), 1, sym_identifier, - STATE(3254), 2, + STATE(3753), 2, sym_comment, sym_include, - [117376] = 5, + [134493] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4508), 1, + ACTIONS(5356), 1, sym_identifier, - STATE(3255), 2, + STATE(3754), 2, sym_comment, sym_include, - [117393] = 5, - ACTIONS(373), 1, + [134510] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4510), 1, - anon_sym_RPAREN, - STATE(3256), 2, + ACTIONS(5358), 1, + sym_identifier, + STATE(3755), 2, sym_comment, sym_include, - [117410] = 5, + [134527] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4512), 1, + ACTIONS(5360), 1, sym_identifier, - STATE(3257), 2, + STATE(3756), 2, sym_comment, sym_include, - [117427] = 5, - ACTIONS(373), 1, + [134544] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4514), 1, + ACTIONS(4382), 1, + aux_sym_primitive_type_token1, + STATE(3757), 2, + sym_comment, + sym_include, + [134561] = 5, + ACTIONS(57), 1, + anon_sym_SLASH_SLASH, + ACTIONS(59), 1, + anon_sym_SLASH_STAR, + ACTIONS(63), 1, + anon_sym_LBRACE, + ACTIONS(5362), 1, sym__integer_literal, - STATE(3258), 2, + STATE(3758), 2, sym_comment, sym_include, - [117444] = 5, - ACTIONS(373), 1, + [134578] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2639), 1, - anon_sym_COLON, - STATE(3259), 2, + ACTIONS(5364), 1, + sym__terminator, + STATE(3759), 2, sym_comment, sym_include, - [117461] = 5, + [134595] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4516), 1, + ACTIONS(5366), 1, sym_identifier, - STATE(3260), 2, + STATE(3760), 2, sym_comment, sym_include, - [117478] = 5, - ACTIONS(373), 1, + [134612] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4518), 1, - anon_sym_RBRACE, - STATE(3261), 2, + ACTIONS(5368), 1, + sym_identifier, + STATE(3761), 2, sym_comment, sym_include, - [117495] = 5, - ACTIONS(373), 1, + [134629] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4520), 1, - anon_sym_RPAREN, - STATE(3262), 2, + ACTIONS(5370), 1, + sym_identifier, + STATE(3762), 2, sym_comment, sym_include, - [117512] = 5, + [134646] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4522), 1, + ACTIONS(5372), 1, sym_identifier, - STATE(3263), 2, + STATE(3763), 2, sym_comment, sym_include, - [117529] = 5, - ACTIONS(3), 1, + [134663] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4524), 1, - aux_sym_comment_token1, - STATE(3264), 2, + ACTIONS(5374), 1, + sym__terminator, + STATE(3764), 2, sym_comment, sym_include, - [117546] = 5, - ACTIONS(373), 1, + [134680] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4526), 1, - sym__terminator, - STATE(3265), 2, + ACTIONS(5376), 1, + anon_sym_LPAREN, + STATE(3765), 2, sym_comment, sym_include, - [117563] = 5, + [134697] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4528), 1, + ACTIONS(5378), 1, sym_identifier, - STATE(3266), 2, + STATE(3766), 2, sym_comment, sym_include, - [117580] = 5, - ACTIONS(373), 1, + [134714] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(3386), 1, - aux_sym_on_error_phrase_token2, - STATE(3267), 2, + ACTIONS(5380), 1, + anon_sym_RBRACE, + STATE(3767), 2, sym_comment, sym_include, - [117597] = 5, - ACTIONS(373), 1, + [134731] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4530), 1, - aux_sym_variable_definition_token5, - STATE(3268), 2, + ACTIONS(5382), 1, + anon_sym_SLASH, + STATE(3768), 2, sym_comment, sym_include, - [117614] = 5, - ACTIONS(373), 1, + [134748] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4532), 1, - sym__terminator, - STATE(3269), 2, + ACTIONS(5384), 1, + anon_sym_LPAREN, + STATE(3769), 2, sym_comment, sym_include, - [117631] = 5, - ACTIONS(373), 1, + [134765] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4534), 1, - anon_sym_RBRACE, - STATE(3270), 2, + ACTIONS(4288), 1, + sym__terminator, + STATE(3770), 2, sym_comment, sym_include, - [117648] = 5, + [134782] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4536), 1, + ACTIONS(5386), 1, sym_identifier, - STATE(3271), 2, - sym_comment, - sym_include, - [117665] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4538), 1, - anon_sym_COLON, - STATE(3272), 2, - sym_comment, - sym_include, - [117682] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4540), 1, - anon_sym_COMMA, - STATE(3273), 2, + STATE(3771), 2, sym_comment, sym_include, - [117699] = 5, - ACTIONS(373), 1, + [134799] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4542), 1, - anon_sym_RPAREN, - STATE(3274), 2, + ACTIONS(4195), 1, + sym__terminator, + STATE(3772), 2, sym_comment, sym_include, - [117716] = 5, - ACTIONS(3), 1, + [134816] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4544), 1, - sym_identifier, - STATE(3275), 2, + ACTIONS(2711), 1, + aux_sym__block_terminator_token1, + STATE(3773), 2, sym_comment, sym_include, - [117733] = 5, - ACTIONS(373), 1, + [134833] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4546), 1, - anon_sym_COLON, - STATE(3276), 2, + ACTIONS(5388), 1, + sym__terminator, + STATE(3774), 2, sym_comment, sym_include, - [117750] = 5, - ACTIONS(373), 1, + [134850] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4548), 1, + ACTIONS(5390), 1, anon_sym_COLON, - STATE(3277), 2, + STATE(3775), 2, sym_comment, sym_include, - [117767] = 5, - ACTIONS(373), 1, + [134867] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4550), 1, - aux_sym_do_statement_token1, - STATE(3278), 2, + ACTIONS(5392), 1, + sym__terminator, + STATE(3776), 2, sym_comment, sym_include, - [117784] = 5, - ACTIONS(373), 1, + [134884] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4552), 1, - anon_sym_COLON, - STATE(3279), 2, + ACTIONS(5394), 1, + ts_builtin_sym_end, + STATE(3777), 2, sym_comment, sym_include, - [117801] = 5, - ACTIONS(373), 1, + [134901] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4554), 1, - anon_sym_EQ, - STATE(3280), 2, + ACTIONS(5396), 1, + sym_identifier, + STATE(3778), 2, sym_comment, sym_include, - [117818] = 5, - ACTIONS(373), 1, + [134918] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(2681), 1, + ACTIONS(5398), 1, anon_sym_COLON, - STATE(3281), 2, + STATE(3779), 2, sym_comment, sym_include, - [117835] = 5, - ACTIONS(373), 1, + [134935] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4556), 1, - sym__terminator, - STATE(3282), 2, + ACTIONS(5400), 1, + sym_identifier, + STATE(3780), 2, sym_comment, sym_include, - [117852] = 5, - ACTIONS(3), 1, + [134952] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4558), 1, - sym_identifier, - STATE(3283), 2, + ACTIONS(5402), 1, + sym__terminator, + STATE(3781), 2, sym_comment, sym_include, - [117869] = 5, - ACTIONS(3), 1, + [134969] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4560), 1, - sym_identifier, - STATE(3284), 2, + ACTIONS(5404), 1, + sym__terminator, + STATE(3782), 2, sym_comment, sym_include, - [117886] = 5, - ACTIONS(3), 1, + [134986] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4562), 1, - sym_identifier, - STATE(3285), 2, + ACTIONS(5406), 1, + anon_sym_RPAREN, + STATE(3783), 2, sym_comment, sym_include, - [117903] = 5, + [135003] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4564), 1, + ACTIONS(5408), 1, sym_identifier, - STATE(3286), 2, + STATE(3784), 2, sym_comment, sym_include, - [117920] = 5, - ACTIONS(3), 1, + [135020] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4566), 1, - sym_identifier, - STATE(3287), 2, + ACTIONS(5410), 1, + anon_sym_COMMA, + STATE(3785), 2, sym_comment, sym_include, - [117937] = 5, - ACTIONS(3), 1, + [135037] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4568), 1, - sym_identifier, - STATE(3288), 2, + ACTIONS(5412), 1, + anon_sym_COLON, + STATE(3786), 2, sym_comment, sym_include, - [117954] = 5, - ACTIONS(3), 1, + [135054] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4570), 1, - sym_identifier, - STATE(3289), 2, + ACTIONS(5414), 1, + anon_sym_RBRACE, + STATE(3787), 2, sym_comment, sym_include, - [117971] = 5, - ACTIONS(3), 1, + [135071] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4572), 1, - sym_identifier, - STATE(3290), 2, + ACTIONS(5416), 1, + anon_sym_RPAREN, + STATE(3788), 2, sym_comment, sym_include, - [117988] = 5, - ACTIONS(373), 1, + [135088] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4574), 1, - aux_sym_procedure_parameter_definition_token2, - STATE(3291), 2, + ACTIONS(5418), 1, + sym__integer_literal, + STATE(3789), 2, sym_comment, sym_include, - [118005] = 5, - ACTIONS(373), 1, + [135105] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4576), 1, - sym__terminator, - STATE(3292), 2, + ACTIONS(5420), 1, + sym__integer_literal, + STATE(3790), 2, sym_comment, sym_include, - [118022] = 5, + [135122] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4578), 1, + ACTIONS(5422), 1, sym_identifier, - STATE(3293), 2, + STATE(3791), 2, sym_comment, sym_include, - [118039] = 5, + [135139] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4580), 1, + ACTIONS(5424), 1, sym_identifier, - STATE(3294), 2, + STATE(3792), 2, sym_comment, sym_include, - [118056] = 5, - ACTIONS(373), 1, + [135156] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(5), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4582), 1, - anon_sym_LPAREN, - STATE(3295), 2, + ACTIONS(5426), 1, + sym_identifier, + STATE(3793), 2, sym_comment, sym_include, - [118073] = 5, + [135173] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4584), 1, + ACTIONS(5428), 1, sym_identifier, - STATE(3296), 2, + STATE(3794), 2, sym_comment, sym_include, - [118090] = 5, - ACTIONS(373), 1, + [135190] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4586), 1, - anon_sym_SLASH, - STATE(3297), 2, + ACTIONS(5430), 1, + anon_sym_RBRACE, + STATE(3795), 2, sym_comment, sym_include, - [118107] = 5, - ACTIONS(373), 1, + [135207] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4588), 1, - anon_sym_RPAREN, - STATE(3298), 2, + ACTIONS(5432), 1, + aux_sym__block_terminator_token1, + STATE(3796), 2, sym_comment, sym_include, - [118124] = 5, - ACTIONS(3), 1, + [135224] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4590), 1, - sym_identifier, - STATE(3299), 2, + ACTIONS(5434), 1, + sym__terminator, + STATE(3797), 2, sym_comment, sym_include, - [118141] = 5, + [135241] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4592), 1, - aux_sym_comment_token2, - STATE(3300), 2, + ACTIONS(5436), 1, + sym_identifier, + STATE(3798), 2, sym_comment, sym_include, - [118158] = 5, - ACTIONS(373), 1, + [135258] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4594), 1, + ACTIONS(5438), 1, sym__terminator, - STATE(3301), 2, + STATE(3799), 2, sym_comment, sym_include, - [118175] = 5, - ACTIONS(373), 1, + [135275] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4596), 1, + ACTIONS(5440), 1, sym__terminator, - STATE(3302), 2, + STATE(3800), 2, sym_comment, sym_include, - [118192] = 5, - ACTIONS(373), 1, + [135292] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4598), 1, - ts_builtin_sym_end, - STATE(3303), 2, + ACTIONS(5442), 1, + aux_sym_procedure_parameter_definition_token2, + STATE(3801), 2, sym_comment, sym_include, - [118209] = 5, - ACTIONS(373), 1, + [135309] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4600), 1, - anon_sym_RPAREN, - STATE(3304), 2, + ACTIONS(5444), 1, + aux_sym_variable_definition_token5, + STATE(3802), 2, sym_comment, sym_include, - [118226] = 5, - ACTIONS(373), 1, + [135326] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4602), 1, - anon_sym_COLON, - STATE(3305), 2, + ACTIONS(5446), 1, + aux_sym_variable_definition_token5, + STATE(3803), 2, sym_comment, sym_include, - [118243] = 5, + [135343] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4604), 1, + ACTIONS(5448), 1, sym_identifier, - STATE(3306), 2, - sym_comment, - sym_include, - [118260] = 5, - ACTIONS(373), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4606), 1, - aux_sym_procedure_parameter_definition_token2, - STATE(3307), 2, + STATE(3804), 2, sym_comment, sym_include, - [118277] = 5, - ACTIONS(3), 1, + [135360] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(5), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(7), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4608), 1, - sym_identifier, - STATE(3308), 2, + ACTIONS(5450), 1, + sym__terminator, + STATE(3805), 2, sym_comment, sym_include, - [118294] = 5, - ACTIONS(373), 1, + [135377] = 5, + ACTIONS(57), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4610), 1, - aux_sym_variable_definition_token5, - STATE(3309), 2, + ACTIONS(3872), 1, + aux_sym_on_error_phrase_token2, + STATE(3806), 2, sym_comment, sym_include, - [118311] = 5, - ACTIONS(373), 1, + [135394] = 5, + ACTIONS(3), 1, anon_sym_SLASH_SLASH, - ACTIONS(375), 1, + ACTIONS(59), 1, anon_sym_SLASH_STAR, - ACTIONS(379), 1, + ACTIONS(63), 1, anon_sym_LBRACE, - ACTIONS(4612), 1, - anon_sym_RPAREN, - STATE(3310), 2, + ACTIONS(5452), 1, + sym_file_name, + STATE(3807), 2, sym_comment, sym_include, - [118328] = 5, + [135411] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4614), 1, - sym_identifier, - STATE(3311), 2, + ACTIONS(5454), 1, + aux_sym_comment_token2, + STATE(3808), 2, sym_comment, sym_include, - [118345] = 5, + [135428] = 5, ACTIONS(3), 1, anon_sym_SLASH_SLASH, ACTIONS(5), 1, anon_sym_SLASH_STAR, ACTIONS(7), 1, anon_sym_LBRACE, - ACTIONS(4616), 1, + ACTIONS(5456), 1, sym_identifier, - STATE(3312), 2, - sym_comment, - sym_include, - [118362] = 5, - ACTIONS(3), 1, - anon_sym_SLASH_SLASH, - ACTIONS(375), 1, - anon_sym_SLASH_STAR, - ACTIONS(379), 1, - anon_sym_LBRACE, - ACTIONS(4618), 1, - sym_file_name, - STATE(3313), 2, + STATE(3809), 2, sym_comment, sym_include, - [118379] = 1, - ACTIONS(4620), 1, + [135445] = 1, + ACTIONS(5458), 1, ts_builtin_sym_end, - [118383] = 1, - ACTIONS(4622), 1, + [135449] = 1, + ACTIONS(5460), 1, ts_builtin_sym_end, - [118387] = 1, - ACTIONS(4624), 1, + [135453] = 1, + ACTIONS(5462), 1, ts_builtin_sym_end, - [118391] = 1, - ACTIONS(4626), 1, + [135457] = 1, + ACTIONS(5464), 1, ts_builtin_sym_end, }; static const uint32_t ts_small_parse_table_map[] = { - [SMALL_STATE(283)] = 0, - [SMALL_STATE(284)] = 79, - [SMALL_STATE(285)] = 155, - [SMALL_STATE(286)] = 231, - [SMALL_STATE(287)] = 310, - [SMALL_STATE(288)] = 389, - [SMALL_STATE(289)] = 517, - [SMALL_STATE(290)] = 645, - [SMALL_STATE(291)] = 773, - [SMALL_STATE(292)] = 901, - [SMALL_STATE(293)] = 1029, - [SMALL_STATE(294)] = 1157, - [SMALL_STATE(295)] = 1285, - [SMALL_STATE(296)] = 1413, - [SMALL_STATE(297)] = 1541, - [SMALL_STATE(298)] = 1669, - [SMALL_STATE(299)] = 1743, - [SMALL_STATE(300)] = 1871, - [SMALL_STATE(301)] = 1999, - [SMALL_STATE(302)] = 2127, - [SMALL_STATE(303)] = 2255, - [SMALL_STATE(304)] = 2383, - [SMALL_STATE(305)] = 2457, - [SMALL_STATE(306)] = 2530, - [SMALL_STATE(307)] = 2603, - [SMALL_STATE(308)] = 2676, - [SMALL_STATE(309)] = 2749, - [SMALL_STATE(310)] = 2822, - [SMALL_STATE(311)] = 2895, - [SMALL_STATE(312)] = 2978, - [SMALL_STATE(313)] = 3051, - [SMALL_STATE(314)] = 3124, - [SMALL_STATE(315)] = 3207, - [SMALL_STATE(316)] = 3280, - [SMALL_STATE(317)] = 3353, - [SMALL_STATE(318)] = 3426, - [SMALL_STATE(319)] = 3499, - [SMALL_STATE(320)] = 3572, - [SMALL_STATE(321)] = 3645, - [SMALL_STATE(322)] = 3718, - [SMALL_STATE(323)] = 3791, - [SMALL_STATE(324)] = 3864, - [SMALL_STATE(325)] = 3937, - [SMALL_STATE(326)] = 4010, - [SMALL_STATE(327)] = 4083, - [SMALL_STATE(328)] = 4156, - [SMALL_STATE(329)] = 4278, - [SMALL_STATE(330)] = 4399, - [SMALL_STATE(331)] = 4472, - [SMALL_STATE(332)] = 4593, - [SMALL_STATE(333)] = 4714, - [SMALL_STATE(334)] = 4835, - [SMALL_STATE(335)] = 4956, - [SMALL_STATE(336)] = 5031, - [SMALL_STATE(337)] = 5103, - [SMALL_STATE(338)] = 5185, - [SMALL_STATE(339)] = 5267, - [SMALL_STATE(340)] = 5349, - [SMALL_STATE(341)] = 5431, - [SMALL_STATE(342)] = 5501, - [SMALL_STATE(343)] = 5583, - [SMALL_STATE(344)] = 5653, - [SMALL_STATE(345)] = 5723, - [SMALL_STATE(346)] = 5799, - [SMALL_STATE(347)] = 5877, - [SMALL_STATE(348)] = 5951, - [SMALL_STATE(349)] = 6031, - [SMALL_STATE(350)] = 6107, - [SMALL_STATE(351)] = 6183, - [SMALL_STATE(352)] = 6265, - [SMALL_STATE(353)] = 6347, - [SMALL_STATE(354)] = 6462, - [SMALL_STATE(355)] = 6577, - [SMALL_STATE(356)] = 6690, - [SMALL_STATE(357)] = 6805, - [SMALL_STATE(358)] = 6920, - [SMALL_STATE(359)] = 7035, - [SMALL_STATE(360)] = 7147, - [SMALL_STATE(361)] = 7213, - [SMALL_STATE(362)] = 7325, - [SMALL_STATE(363)] = 7437, - [SMALL_STATE(364)] = 7503, - [SMALL_STATE(365)] = 7571, - [SMALL_STATE(366)] = 7683, - [SMALL_STATE(367)] = 7751, - [SMALL_STATE(368)] = 7863, - [SMALL_STATE(369)] = 7931, - [SMALL_STATE(370)] = 7999, - [SMALL_STATE(371)] = 8108, - [SMALL_STATE(372)] = 8217, - [SMALL_STATE(373)] = 8326, - [SMALL_STATE(374)] = 8435, - [SMALL_STATE(375)] = 8544, - [SMALL_STATE(376)] = 8653, - [SMALL_STATE(377)] = 8762, - [SMALL_STATE(378)] = 8871, - [SMALL_STATE(379)] = 8980, - [SMALL_STATE(380)] = 9089, - [SMALL_STATE(381)] = 9198, - [SMALL_STATE(382)] = 9307, - [SMALL_STATE(383)] = 9416, - [SMALL_STATE(384)] = 9525, - [SMALL_STATE(385)] = 9634, - [SMALL_STATE(386)] = 9743, - [SMALL_STATE(387)] = 9852, - [SMALL_STATE(388)] = 9961, - [SMALL_STATE(389)] = 10070, - [SMALL_STATE(390)] = 10179, - [SMALL_STATE(391)] = 10288, - [SMALL_STATE(392)] = 10397, - [SMALL_STATE(393)] = 10506, - [SMALL_STATE(394)] = 10571, - [SMALL_STATE(395)] = 10680, - [SMALL_STATE(396)] = 10789, - [SMALL_STATE(397)] = 10898, - [SMALL_STATE(398)] = 11007, - [SMALL_STATE(399)] = 11116, - [SMALL_STATE(400)] = 11225, - [SMALL_STATE(401)] = 11334, - [SMALL_STATE(402)] = 11443, - [SMALL_STATE(403)] = 11552, - [SMALL_STATE(404)] = 11615, - [SMALL_STATE(405)] = 11724, - [SMALL_STATE(406)] = 11833, - [SMALL_STATE(407)] = 11942, - [SMALL_STATE(408)] = 12051, - [SMALL_STATE(409)] = 12160, - [SMALL_STATE(410)] = 12269, - [SMALL_STATE(411)] = 12332, - [SMALL_STATE(412)] = 12441, - [SMALL_STATE(413)] = 12506, - [SMALL_STATE(414)] = 12615, - [SMALL_STATE(415)] = 12724, - [SMALL_STATE(416)] = 12833, - [SMALL_STATE(417)] = 12942, - [SMALL_STATE(418)] = 13051, - [SMALL_STATE(419)] = 13160, - [SMALL_STATE(420)] = 13269, - [SMALL_STATE(421)] = 13378, - [SMALL_STATE(422)] = 13487, - [SMALL_STATE(423)] = 13596, - [SMALL_STATE(424)] = 13705, - [SMALL_STATE(425)] = 13814, - [SMALL_STATE(426)] = 13923, - [SMALL_STATE(427)] = 14032, - [SMALL_STATE(428)] = 14141, - [SMALL_STATE(429)] = 14250, - [SMALL_STATE(430)] = 14359, - [SMALL_STATE(431)] = 14468, - [SMALL_STATE(432)] = 14577, - [SMALL_STATE(433)] = 14686, - [SMALL_STATE(434)] = 14795, - [SMALL_STATE(435)] = 14904, - [SMALL_STATE(436)] = 15013, - [SMALL_STATE(437)] = 15122, - [SMALL_STATE(438)] = 15231, - [SMALL_STATE(439)] = 15340, - [SMALL_STATE(440)] = 15449, - [SMALL_STATE(441)] = 15558, - [SMALL_STATE(442)] = 15667, - [SMALL_STATE(443)] = 15776, - [SMALL_STATE(444)] = 15885, - [SMALL_STATE(445)] = 15994, - [SMALL_STATE(446)] = 16103, - [SMALL_STATE(447)] = 16212, - [SMALL_STATE(448)] = 16321, - [SMALL_STATE(449)] = 16430, - [SMALL_STATE(450)] = 16539, - [SMALL_STATE(451)] = 16648, - [SMALL_STATE(452)] = 16757, - [SMALL_STATE(453)] = 16866, - [SMALL_STATE(454)] = 16975, - [SMALL_STATE(455)] = 17084, - [SMALL_STATE(456)] = 17193, - [SMALL_STATE(457)] = 17302, - [SMALL_STATE(458)] = 17367, - [SMALL_STATE(459)] = 17476, - [SMALL_STATE(460)] = 17585, - [SMALL_STATE(461)] = 17694, - [SMALL_STATE(462)] = 17803, - [SMALL_STATE(463)] = 17912, - [SMALL_STATE(464)] = 18021, - [SMALL_STATE(465)] = 18086, - [SMALL_STATE(466)] = 18195, - [SMALL_STATE(467)] = 18304, - [SMALL_STATE(468)] = 18413, - [SMALL_STATE(469)] = 18522, - [SMALL_STATE(470)] = 18631, - [SMALL_STATE(471)] = 18740, - [SMALL_STATE(472)] = 18849, - [SMALL_STATE(473)] = 18958, - [SMALL_STATE(474)] = 19067, - [SMALL_STATE(475)] = 19176, - [SMALL_STATE(476)] = 19285, - [SMALL_STATE(477)] = 19394, - [SMALL_STATE(478)] = 19503, - [SMALL_STATE(479)] = 19612, - [SMALL_STATE(480)] = 19721, - [SMALL_STATE(481)] = 19830, - [SMALL_STATE(482)] = 19939, - [SMALL_STATE(483)] = 20048, - [SMALL_STATE(484)] = 20157, - [SMALL_STATE(485)] = 20266, - [SMALL_STATE(486)] = 20329, - [SMALL_STATE(487)] = 20438, - [SMALL_STATE(488)] = 20547, - [SMALL_STATE(489)] = 20656, - [SMALL_STATE(490)] = 20765, - [SMALL_STATE(491)] = 20874, - [SMALL_STATE(492)] = 20983, - [SMALL_STATE(493)] = 21048, - [SMALL_STATE(494)] = 21157, - [SMALL_STATE(495)] = 21266, - [SMALL_STATE(496)] = 21375, - [SMALL_STATE(497)] = 21484, - [SMALL_STATE(498)] = 21593, - [SMALL_STATE(499)] = 21702, - [SMALL_STATE(500)] = 21811, - [SMALL_STATE(501)] = 21920, - [SMALL_STATE(502)] = 22029, - [SMALL_STATE(503)] = 22138, - [SMALL_STATE(504)] = 22247, - [SMALL_STATE(505)] = 22356, - [SMALL_STATE(506)] = 22465, - [SMALL_STATE(507)] = 22574, - [SMALL_STATE(508)] = 22683, - [SMALL_STATE(509)] = 22792, - [SMALL_STATE(510)] = 22901, - [SMALL_STATE(511)] = 23010, - [SMALL_STATE(512)] = 23119, - [SMALL_STATE(513)] = 23228, - [SMALL_STATE(514)] = 23337, - [SMALL_STATE(515)] = 23446, - [SMALL_STATE(516)] = 23508, - [SMALL_STATE(517)] = 23570, - [SMALL_STATE(518)] = 23632, - [SMALL_STATE(519)] = 23694, - [SMALL_STATE(520)] = 23756, - [SMALL_STATE(521)] = 23818, - [SMALL_STATE(522)] = 23880, - [SMALL_STATE(523)] = 23942, - [SMALL_STATE(524)] = 24004, - [SMALL_STATE(525)] = 24066, - [SMALL_STATE(526)] = 24128, - [SMALL_STATE(527)] = 24190, - [SMALL_STATE(528)] = 24252, - [SMALL_STATE(529)] = 24314, - [SMALL_STATE(530)] = 24376, - [SMALL_STATE(531)] = 24438, - [SMALL_STATE(532)] = 24500, - [SMALL_STATE(533)] = 24562, - [SMALL_STATE(534)] = 24624, - [SMALL_STATE(535)] = 24686, - [SMALL_STATE(536)] = 24748, - [SMALL_STATE(537)] = 24810, - [SMALL_STATE(538)] = 24872, - [SMALL_STATE(539)] = 24934, - [SMALL_STATE(540)] = 24996, - [SMALL_STATE(541)] = 25058, - [SMALL_STATE(542)] = 25120, - [SMALL_STATE(543)] = 25182, - [SMALL_STATE(544)] = 25267, - [SMALL_STATE(545)] = 25352, - [SMALL_STATE(546)] = 25431, - [SMALL_STATE(547)] = 25504, - [SMALL_STATE(548)] = 25589, - [SMALL_STATE(549)] = 25666, - [SMALL_STATE(550)] = 25751, - [SMALL_STATE(551)] = 25836, - [SMALL_STATE(552)] = 25921, - [SMALL_STATE(553)] = 26004, - [SMALL_STATE(554)] = 26070, - [SMALL_STATE(555)] = 26136, - [SMALL_STATE(556)] = 26232, - [SMALL_STATE(557)] = 26328, - [SMALL_STATE(558)] = 26424, - [SMALL_STATE(559)] = 26520, - [SMALL_STATE(560)] = 26616, - [SMALL_STATE(561)] = 26712, - [SMALL_STATE(562)] = 26808, - [SMALL_STATE(563)] = 26904, - [SMALL_STATE(564)] = 27000, - [SMALL_STATE(565)] = 27096, - [SMALL_STATE(566)] = 27158, - [SMALL_STATE(567)] = 27220, - [SMALL_STATE(568)] = 27289, - [SMALL_STATE(569)] = 27358, - [SMALL_STATE(570)] = 27434, - [SMALL_STATE(571)] = 27506, - [SMALL_STATE(572)] = 27572, - [SMALL_STATE(573)] = 27648, - [SMALL_STATE(574)] = 27724, - [SMALL_STATE(575)] = 27794, - [SMALL_STATE(576)] = 27870, - [SMALL_STATE(577)] = 27936, - [SMALL_STATE(578)] = 28010, - [SMALL_STATE(579)] = 28086, - [SMALL_STATE(580)] = 28162, - [SMALL_STATE(581)] = 28238, - [SMALL_STATE(582)] = 28314, - [SMALL_STATE(583)] = 28390, - [SMALL_STATE(584)] = 28466, - [SMALL_STATE(585)] = 28538, - [SMALL_STATE(586)] = 28600, - [SMALL_STATE(587)] = 28676, - [SMALL_STATE(588)] = 28752, - [SMALL_STATE(589)] = 28828, - [SMALL_STATE(590)] = 28904, - [SMALL_STATE(591)] = 28978, - [SMALL_STATE(592)] = 29038, - [SMALL_STATE(593)] = 29108, - [SMALL_STATE(594)] = 29175, - [SMALL_STATE(595)] = 29232, - [SMALL_STATE(596)] = 29299, - [SMALL_STATE(597)] = 29357, - [SMALL_STATE(598)] = 29429, - [SMALL_STATE(599)] = 29503, - [SMALL_STATE(600)] = 29577, - [SMALL_STATE(601)] = 29651, - [SMALL_STATE(602)] = 29725, - [SMALL_STATE(603)] = 29783, - [SMALL_STATE(604)] = 29851, - [SMALL_STATE(605)] = 29921, - [SMALL_STATE(606)] = 29981, - [SMALL_STATE(607)] = 30055, - [SMALL_STATE(608)] = 30129, - [SMALL_STATE(609)] = 30193, - [SMALL_STATE(610)] = 30267, - [SMALL_STATE(611)] = 30354, - [SMALL_STATE(612)] = 30441, - [SMALL_STATE(613)] = 30496, - [SMALL_STATE(614)] = 30583, - [SMALL_STATE(615)] = 30670, - [SMALL_STATE(616)] = 30757, - [SMALL_STATE(617)] = 30844, - [SMALL_STATE(618)] = 30902, - [SMALL_STATE(619)] = 30960, - [SMALL_STATE(620)] = 31018, - [SMALL_STATE(621)] = 31074, - [SMALL_STATE(622)] = 31130, - [SMALL_STATE(623)] = 31202, - [SMALL_STATE(624)] = 31255, - [SMALL_STATE(625)] = 31310, - [SMALL_STATE(626)] = 31365, - [SMALL_STATE(627)] = 31418, - [SMALL_STATE(628)] = 31471, - [SMALL_STATE(629)] = 31526, - [SMALL_STATE(630)] = 31597, - [SMALL_STATE(631)] = 31649, - [SMALL_STATE(632)] = 31701, - [SMALL_STATE(633)] = 31753, - [SMALL_STATE(634)] = 31805, - [SMALL_STATE(635)] = 31857, - [SMALL_STATE(636)] = 31909, - [SMALL_STATE(637)] = 31961, - [SMALL_STATE(638)] = 32013, - [SMALL_STATE(639)] = 32065, - [SMALL_STATE(640)] = 32117, - [SMALL_STATE(641)] = 32169, - [SMALL_STATE(642)] = 32221, - [SMALL_STATE(643)] = 32273, - [SMALL_STATE(644)] = 32325, - [SMALL_STATE(645)] = 32377, - [SMALL_STATE(646)] = 32429, - [SMALL_STATE(647)] = 32481, - [SMALL_STATE(648)] = 32539, - [SMALL_STATE(649)] = 32591, - [SMALL_STATE(650)] = 32643, - [SMALL_STATE(651)] = 32695, - [SMALL_STATE(652)] = 32753, - [SMALL_STATE(653)] = 32805, - [SMALL_STATE(654)] = 32855, - [SMALL_STATE(655)] = 32907, - [SMALL_STATE(656)] = 32959, - [SMALL_STATE(657)] = 33011, - [SMALL_STATE(658)] = 33063, - [SMALL_STATE(659)] = 33115, - [SMALL_STATE(660)] = 33167, - [SMALL_STATE(661)] = 33219, - [SMALL_STATE(662)] = 33271, - [SMALL_STATE(663)] = 33334, - [SMALL_STATE(664)] = 33397, - [SMALL_STATE(665)] = 33458, - [SMALL_STATE(666)] = 33517, - [SMALL_STATE(667)] = 33576, - [SMALL_STATE(668)] = 33631, - [SMALL_STATE(669)] = 33688, - [SMALL_STATE(670)] = 33751, - [SMALL_STATE(671)] = 33814, - [SMALL_STATE(672)] = 33877, - [SMALL_STATE(673)] = 33940, - [SMALL_STATE(674)] = 34003, - [SMALL_STATE(675)] = 34052, - [SMALL_STATE(676)] = 34127, - [SMALL_STATE(677)] = 34202, - [SMALL_STATE(678)] = 34261, - [SMALL_STATE(679)] = 34325, - [SMALL_STATE(680)] = 34383, - [SMALL_STATE(681)] = 34445, - [SMALL_STATE(682)] = 34509, - [SMALL_STATE(683)] = 34565, - [SMALL_STATE(684)] = 34625, - [SMALL_STATE(685)] = 34689, - [SMALL_STATE(686)] = 34753, - [SMALL_STATE(687)] = 34817, - [SMALL_STATE(688)] = 34881, - [SMALL_STATE(689)] = 34945, - [SMALL_STATE(690)] = 35010, - [SMALL_STATE(691)] = 35059, - [SMALL_STATE(692)] = 35108, - [SMALL_STATE(693)] = 35175, - [SMALL_STATE(694)] = 35242, - [SMALL_STATE(695)] = 35291, - [SMALL_STATE(696)] = 35358, - [SMALL_STATE(697)] = 35425, - [SMALL_STATE(698)] = 35492, - [SMALL_STATE(699)] = 35559, - [SMALL_STATE(700)] = 35606, - [SMALL_STATE(701)] = 35673, - [SMALL_STATE(702)] = 35730, - [SMALL_STATE(703)] = 35791, - [SMALL_STATE(704)] = 35838, - [SMALL_STATE(705)] = 35885, - [SMALL_STATE(706)] = 35952, - [SMALL_STATE(707)] = 36015, - [SMALL_STATE(708)] = 36082, - [SMALL_STATE(709)] = 36149, - [SMALL_STATE(710)] = 36198, - [SMALL_STATE(711)] = 36264, - [SMALL_STATE(712)] = 36330, - [SMALL_STATE(713)] = 36396, - [SMALL_STATE(714)] = 36462, - [SMALL_STATE(715)] = 36528, - [SMALL_STATE(716)] = 36594, - [SMALL_STATE(717)] = 36660, - [SMALL_STATE(718)] = 36726, - [SMALL_STATE(719)] = 36792, - [SMALL_STATE(720)] = 36850, - [SMALL_STATE(721)] = 36916, - [SMALL_STATE(722)] = 36982, - [SMALL_STATE(723)] = 37028, - [SMALL_STATE(724)] = 37094, - [SMALL_STATE(725)] = 37160, - [SMALL_STATE(726)] = 37226, - [SMALL_STATE(727)] = 37292, - [SMALL_STATE(728)] = 37358, - [SMALL_STATE(729)] = 37424, - [SMALL_STATE(730)] = 37474, - [SMALL_STATE(731)] = 37540, - [SMALL_STATE(732)] = 37606, - [SMALL_STATE(733)] = 37672, - [SMALL_STATE(734)] = 37718, - [SMALL_STATE(735)] = 37762, - [SMALL_STATE(736)] = 37828, - [SMALL_STATE(737)] = 37894, - [SMALL_STATE(738)] = 37938, - [SMALL_STATE(739)] = 37984, - [SMALL_STATE(740)] = 38050, - [SMALL_STATE(741)] = 38116, - [SMALL_STATE(742)] = 38166, - [SMALL_STATE(743)] = 38212, - [SMALL_STATE(744)] = 38278, - [SMALL_STATE(745)] = 38344, - [SMALL_STATE(746)] = 38410, - [SMALL_STATE(747)] = 38468, - [SMALL_STATE(748)] = 38534, - [SMALL_STATE(749)] = 38582, - [SMALL_STATE(750)] = 38630, - [SMALL_STATE(751)] = 38696, - [SMALL_STATE(752)] = 38744, - [SMALL_STATE(753)] = 38794, - [SMALL_STATE(754)] = 38860, - [SMALL_STATE(755)] = 38926, - [SMALL_STATE(756)] = 38992, - [SMALL_STATE(757)] = 39058, - [SMALL_STATE(758)] = 39124, - [SMALL_STATE(759)] = 39190, - [SMALL_STATE(760)] = 39256, - [SMALL_STATE(761)] = 39300, - [SMALL_STATE(762)] = 39366, - [SMALL_STATE(763)] = 39416, - [SMALL_STATE(764)] = 39482, - [SMALL_STATE(765)] = 39548, - [SMALL_STATE(766)] = 39614, - [SMALL_STATE(767)] = 39680, - [SMALL_STATE(768)] = 39746, - [SMALL_STATE(769)] = 39812, - [SMALL_STATE(770)] = 39878, - [SMALL_STATE(771)] = 39944, - [SMALL_STATE(772)] = 39987, - [SMALL_STATE(773)] = 40030, - [SMALL_STATE(774)] = 40073, - [SMALL_STATE(775)] = 40116, - [SMALL_STATE(776)] = 40159, - [SMALL_STATE(777)] = 40202, - [SMALL_STATE(778)] = 40245, - [SMALL_STATE(779)] = 40288, - [SMALL_STATE(780)] = 40335, - [SMALL_STATE(781)] = 40378, - [SMALL_STATE(782)] = 40421, - [SMALL_STATE(783)] = 40464, - [SMALL_STATE(784)] = 40509, - [SMALL_STATE(785)] = 40552, - [SMALL_STATE(786)] = 40595, - [SMALL_STATE(787)] = 40638, - [SMALL_STATE(788)] = 40681, - [SMALL_STATE(789)] = 40724, - [SMALL_STATE(790)] = 40767, - [SMALL_STATE(791)] = 40810, - [SMALL_STATE(792)] = 40853, - [SMALL_STATE(793)] = 40896, - [SMALL_STATE(794)] = 40941, - [SMALL_STATE(795)] = 40984, - [SMALL_STATE(796)] = 41027, - [SMALL_STATE(797)] = 41070, - [SMALL_STATE(798)] = 41117, - [SMALL_STATE(799)] = 41160, - [SMALL_STATE(800)] = 41203, - [SMALL_STATE(801)] = 41248, - [SMALL_STATE(802)] = 41291, - [SMALL_STATE(803)] = 41334, - [SMALL_STATE(804)] = 41377, - [SMALL_STATE(805)] = 41421, - [SMALL_STATE(806)] = 41465, - [SMALL_STATE(807)] = 41509, - [SMALL_STATE(808)] = 41553, - [SMALL_STATE(809)] = 41597, - [SMALL_STATE(810)] = 41641, - [SMALL_STATE(811)] = 41685, - [SMALL_STATE(812)] = 41735, - [SMALL_STATE(813)] = 41779, - [SMALL_STATE(814)] = 41823, - [SMALL_STATE(815)] = 41867, - [SMALL_STATE(816)] = 41911, - [SMALL_STATE(817)] = 41955, - [SMALL_STATE(818)] = 42007, - [SMALL_STATE(819)] = 42059, - [SMALL_STATE(820)] = 42103, - [SMALL_STATE(821)] = 42153, - [SMALL_STATE(822)] = 42197, - [SMALL_STATE(823)] = 42241, - [SMALL_STATE(824)] = 42285, - [SMALL_STATE(825)] = 42329, - [SMALL_STATE(826)] = 42373, - [SMALL_STATE(827)] = 42417, - [SMALL_STATE(828)] = 42461, - [SMALL_STATE(829)] = 42505, - [SMALL_STATE(830)] = 42555, - [SMALL_STATE(831)] = 42599, - [SMALL_STATE(832)] = 42645, - [SMALL_STATE(833)] = 42689, - [SMALL_STATE(834)] = 42735, - [SMALL_STATE(835)] = 42779, - [SMALL_STATE(836)] = 42823, - [SMALL_STATE(837)] = 42867, - [SMALL_STATE(838)] = 42911, - [SMALL_STATE(839)] = 42955, - [SMALL_STATE(840)] = 43003, - [SMALL_STATE(841)] = 43087, - [SMALL_STATE(842)] = 43171, - [SMALL_STATE(843)] = 43255, - [SMALL_STATE(844)] = 43339, - [SMALL_STATE(845)] = 43423, - [SMALL_STATE(846)] = 43507, - [SMALL_STATE(847)] = 43591, - [SMALL_STATE(848)] = 43675, - [SMALL_STATE(849)] = 43759, - [SMALL_STATE(850)] = 43843, - [SMALL_STATE(851)] = 43884, - [SMALL_STATE(852)] = 43927, - [SMALL_STATE(853)] = 43970, - [SMALL_STATE(854)] = 44013, - [SMALL_STATE(855)] = 44056, - [SMALL_STATE(856)] = 44099, - [SMALL_STATE(857)] = 44142, - [SMALL_STATE(858)] = 44185, - [SMALL_STATE(859)] = 44228, - [SMALL_STATE(860)] = 44271, - [SMALL_STATE(861)] = 44314, - [SMALL_STATE(862)] = 44357, - [SMALL_STATE(863)] = 44400, - [SMALL_STATE(864)] = 44443, - [SMALL_STATE(865)] = 44486, - [SMALL_STATE(866)] = 44529, - [SMALL_STATE(867)] = 44572, - [SMALL_STATE(868)] = 44615, - [SMALL_STATE(869)] = 44658, - [SMALL_STATE(870)] = 44701, - [SMALL_STATE(871)] = 44744, - [SMALL_STATE(872)] = 44787, - [SMALL_STATE(873)] = 44830, - [SMALL_STATE(874)] = 44873, - [SMALL_STATE(875)] = 44916, - [SMALL_STATE(876)] = 44959, - [SMALL_STATE(877)] = 45002, - [SMALL_STATE(878)] = 45045, - [SMALL_STATE(879)] = 45086, - [SMALL_STATE(880)] = 45129, - [SMALL_STATE(881)] = 45172, - [SMALL_STATE(882)] = 45215, - [SMALL_STATE(883)] = 45258, - [SMALL_STATE(884)] = 45301, - [SMALL_STATE(885)] = 45344, - [SMALL_STATE(886)] = 45387, - [SMALL_STATE(887)] = 45430, - [SMALL_STATE(888)] = 45473, - [SMALL_STATE(889)] = 45516, - [SMALL_STATE(890)] = 45559, - [SMALL_STATE(891)] = 45602, - [SMALL_STATE(892)] = 45645, - [SMALL_STATE(893)] = 45688, - [SMALL_STATE(894)] = 45731, - [SMALL_STATE(895)] = 45774, - [SMALL_STATE(896)] = 45817, - [SMALL_STATE(897)] = 45860, - [SMALL_STATE(898)] = 45903, - [SMALL_STATE(899)] = 45946, - [SMALL_STATE(900)] = 45989, - [SMALL_STATE(901)] = 46032, - [SMALL_STATE(902)] = 46075, - [SMALL_STATE(903)] = 46118, - [SMALL_STATE(904)] = 46161, - [SMALL_STATE(905)] = 46204, - [SMALL_STATE(906)] = 46247, - [SMALL_STATE(907)] = 46290, - [SMALL_STATE(908)] = 46333, - [SMALL_STATE(909)] = 46376, - [SMALL_STATE(910)] = 46419, - [SMALL_STATE(911)] = 46462, - [SMALL_STATE(912)] = 46505, - [SMALL_STATE(913)] = 46548, - [SMALL_STATE(914)] = 46591, - [SMALL_STATE(915)] = 46634, - [SMALL_STATE(916)] = 46677, - [SMALL_STATE(917)] = 46720, - [SMALL_STATE(918)] = 46763, - [SMALL_STATE(919)] = 46806, - [SMALL_STATE(920)] = 46849, - [SMALL_STATE(921)] = 46892, - [SMALL_STATE(922)] = 46933, - [SMALL_STATE(923)] = 46974, - [SMALL_STATE(924)] = 47015, - [SMALL_STATE(925)] = 47056, - [SMALL_STATE(926)] = 47097, - [SMALL_STATE(927)] = 47138, - [SMALL_STATE(928)] = 47179, - [SMALL_STATE(929)] = 47220, - [SMALL_STATE(930)] = 47263, - [SMALL_STATE(931)] = 47304, - [SMALL_STATE(932)] = 47345, - [SMALL_STATE(933)] = 47386, - [SMALL_STATE(934)] = 47427, - [SMALL_STATE(935)] = 47468, - [SMALL_STATE(936)] = 47509, - [SMALL_STATE(937)] = 47550, - [SMALL_STATE(938)] = 47591, - [SMALL_STATE(939)] = 47632, - [SMALL_STATE(940)] = 47673, - [SMALL_STATE(941)] = 47714, - [SMALL_STATE(942)] = 47755, - [SMALL_STATE(943)] = 47796, - [SMALL_STATE(944)] = 47837, - [SMALL_STATE(945)] = 47878, - [SMALL_STATE(946)] = 47919, - [SMALL_STATE(947)] = 47960, - [SMALL_STATE(948)] = 48001, - [SMALL_STATE(949)] = 48042, - [SMALL_STATE(950)] = 48083, - [SMALL_STATE(951)] = 48124, - [SMALL_STATE(952)] = 48165, - [SMALL_STATE(953)] = 48206, - [SMALL_STATE(954)] = 48247, - [SMALL_STATE(955)] = 48288, - [SMALL_STATE(956)] = 48329, - [SMALL_STATE(957)] = 48370, - [SMALL_STATE(958)] = 48411, - [SMALL_STATE(959)] = 48452, - [SMALL_STATE(960)] = 48493, - [SMALL_STATE(961)] = 48534, - [SMALL_STATE(962)] = 48575, - [SMALL_STATE(963)] = 48618, - [SMALL_STATE(964)] = 48659, - [SMALL_STATE(965)] = 48700, - [SMALL_STATE(966)] = 48741, - [SMALL_STATE(967)] = 48782, - [SMALL_STATE(968)] = 48823, - [SMALL_STATE(969)] = 48864, - [SMALL_STATE(970)] = 48905, - [SMALL_STATE(971)] = 48946, - [SMALL_STATE(972)] = 48987, - [SMALL_STATE(973)] = 49028, - [SMALL_STATE(974)] = 49069, - [SMALL_STATE(975)] = 49110, - [SMALL_STATE(976)] = 49151, - [SMALL_STATE(977)] = 49192, - [SMALL_STATE(978)] = 49233, - [SMALL_STATE(979)] = 49312, - [SMALL_STATE(980)] = 49353, - [SMALL_STATE(981)] = 49394, - [SMALL_STATE(982)] = 49435, - [SMALL_STATE(983)] = 49476, - [SMALL_STATE(984)] = 49517, - [SMALL_STATE(985)] = 49558, - [SMALL_STATE(986)] = 49599, - [SMALL_STATE(987)] = 49640, - [SMALL_STATE(988)] = 49681, - [SMALL_STATE(989)] = 49722, - [SMALL_STATE(990)] = 49763, - [SMALL_STATE(991)] = 49804, - [SMALL_STATE(992)] = 49845, - [SMALL_STATE(993)] = 49886, - [SMALL_STATE(994)] = 49927, - [SMALL_STATE(995)] = 49968, - [SMALL_STATE(996)] = 50009, - [SMALL_STATE(997)] = 50050, - [SMALL_STATE(998)] = 50091, - [SMALL_STATE(999)] = 50134, - [SMALL_STATE(1000)] = 50177, - [SMALL_STATE(1001)] = 50220, - [SMALL_STATE(1002)] = 50263, - [SMALL_STATE(1003)] = 50306, - [SMALL_STATE(1004)] = 50348, - [SMALL_STATE(1005)] = 50388, - [SMALL_STATE(1006)] = 50430, - [SMALL_STATE(1007)] = 50472, - [SMALL_STATE(1008)] = 50514, - [SMALL_STATE(1009)] = 50556, - [SMALL_STATE(1010)] = 50598, - [SMALL_STATE(1011)] = 50640, - [SMALL_STATE(1012)] = 50682, - [SMALL_STATE(1013)] = 50724, - [SMALL_STATE(1014)] = 50766, - [SMALL_STATE(1015)] = 50808, - [SMALL_STATE(1016)] = 50886, - [SMALL_STATE(1017)] = 50954, - [SMALL_STATE(1018)] = 50996, - [SMALL_STATE(1019)] = 51038, - [SMALL_STATE(1020)] = 51080, - [SMALL_STATE(1021)] = 51158, - [SMALL_STATE(1022)] = 51200, - [SMALL_STATE(1023)] = 51242, - [SMALL_STATE(1024)] = 51284, - [SMALL_STATE(1025)] = 51326, - [SMALL_STATE(1026)] = 51368, - [SMALL_STATE(1027)] = 51410, - [SMALL_STATE(1028)] = 51452, - [SMALL_STATE(1029)] = 51494, - [SMALL_STATE(1030)] = 51536, - [SMALL_STATE(1031)] = 51578, - [SMALL_STATE(1032)] = 51620, - [SMALL_STATE(1033)] = 51662, - [SMALL_STATE(1034)] = 51704, - [SMALL_STATE(1035)] = 51746, - [SMALL_STATE(1036)] = 51788, - [SMALL_STATE(1037)] = 51830, - [SMALL_STATE(1038)] = 51872, - [SMALL_STATE(1039)] = 51914, - [SMALL_STATE(1040)] = 51956, - [SMALL_STATE(1041)] = 51998, - [SMALL_STATE(1042)] = 52040, - [SMALL_STATE(1043)] = 52082, - [SMALL_STATE(1044)] = 52124, - [SMALL_STATE(1045)] = 52166, - [SMALL_STATE(1046)] = 52208, - [SMALL_STATE(1047)] = 52250, - [SMALL_STATE(1048)] = 52292, - [SMALL_STATE(1049)] = 52334, - [SMALL_STATE(1050)] = 52382, - [SMALL_STATE(1051)] = 52424, - [SMALL_STATE(1052)] = 52502, - [SMALL_STATE(1053)] = 52544, - [SMALL_STATE(1054)] = 52586, - [SMALL_STATE(1055)] = 52628, - [SMALL_STATE(1056)] = 52670, - [SMALL_STATE(1057)] = 52712, - [SMALL_STATE(1058)] = 52754, - [SMALL_STATE(1059)] = 52796, - [SMALL_STATE(1060)] = 52838, - [SMALL_STATE(1061)] = 52880, - [SMALL_STATE(1062)] = 52922, - [SMALL_STATE(1063)] = 52964, - [SMALL_STATE(1064)] = 53042, - [SMALL_STATE(1065)] = 53084, - [SMALL_STATE(1066)] = 53126, - [SMALL_STATE(1067)] = 53168, - [SMALL_STATE(1068)] = 53210, - [SMALL_STATE(1069)] = 53252, - [SMALL_STATE(1070)] = 53294, - [SMALL_STATE(1071)] = 53336, - [SMALL_STATE(1072)] = 53378, - [SMALL_STATE(1073)] = 53420, - [SMALL_STATE(1074)] = 53462, - [SMALL_STATE(1075)] = 53504, - [SMALL_STATE(1076)] = 53572, - [SMALL_STATE(1077)] = 53614, - [SMALL_STATE(1078)] = 53656, - [SMALL_STATE(1079)] = 53698, - [SMALL_STATE(1080)] = 53740, - [SMALL_STATE(1081)] = 53782, - [SMALL_STATE(1082)] = 53824, - [SMALL_STATE(1083)] = 53866, - [SMALL_STATE(1084)] = 53908, - [SMALL_STATE(1085)] = 53950, - [SMALL_STATE(1086)] = 53992, - [SMALL_STATE(1087)] = 54034, - [SMALL_STATE(1088)] = 54076, - [SMALL_STATE(1089)] = 54118, - [SMALL_STATE(1090)] = 54160, - [SMALL_STATE(1091)] = 54202, - [SMALL_STATE(1092)] = 54244, - [SMALL_STATE(1093)] = 54286, - [SMALL_STATE(1094)] = 54328, - [SMALL_STATE(1095)] = 54370, - [SMALL_STATE(1096)] = 54412, - [SMALL_STATE(1097)] = 54454, - [SMALL_STATE(1098)] = 54532, - [SMALL_STATE(1099)] = 54574, - [SMALL_STATE(1100)] = 54616, - [SMALL_STATE(1101)] = 54658, - [SMALL_STATE(1102)] = 54700, - [SMALL_STATE(1103)] = 54742, - [SMALL_STATE(1104)] = 54784, - [SMALL_STATE(1105)] = 54826, - [SMALL_STATE(1106)] = 54868, - [SMALL_STATE(1107)] = 54910, - [SMALL_STATE(1108)] = 54952, - [SMALL_STATE(1109)] = 54994, - [SMALL_STATE(1110)] = 55036, - [SMALL_STATE(1111)] = 55078, - [SMALL_STATE(1112)] = 55120, - [SMALL_STATE(1113)] = 55162, - [SMALL_STATE(1114)] = 55204, - [SMALL_STATE(1115)] = 55246, - [SMALL_STATE(1116)] = 55288, - [SMALL_STATE(1117)] = 55330, - [SMALL_STATE(1118)] = 55372, - [SMALL_STATE(1119)] = 55450, - [SMALL_STATE(1120)] = 55492, - [SMALL_STATE(1121)] = 55534, - [SMALL_STATE(1122)] = 55576, - [SMALL_STATE(1123)] = 55618, - [SMALL_STATE(1124)] = 55660, - [SMALL_STATE(1125)] = 55702, - [SMALL_STATE(1126)] = 55744, - [SMALL_STATE(1127)] = 55786, - [SMALL_STATE(1128)] = 55828, - [SMALL_STATE(1129)] = 55870, - [SMALL_STATE(1130)] = 55912, - [SMALL_STATE(1131)] = 55954, - [SMALL_STATE(1132)] = 55996, - [SMALL_STATE(1133)] = 56038, - [SMALL_STATE(1134)] = 56080, - [SMALL_STATE(1135)] = 56122, - [SMALL_STATE(1136)] = 56164, - [SMALL_STATE(1137)] = 56206, - [SMALL_STATE(1138)] = 56248, - [SMALL_STATE(1139)] = 56290, - [SMALL_STATE(1140)] = 56330, - [SMALL_STATE(1141)] = 56376, - [SMALL_STATE(1142)] = 56416, - [SMALL_STATE(1143)] = 56456, - [SMALL_STATE(1144)] = 56496, - [SMALL_STATE(1145)] = 56538, - [SMALL_STATE(1146)] = 56578, - [SMALL_STATE(1147)] = 56620, - [SMALL_STATE(1148)] = 56662, - [SMALL_STATE(1149)] = 56704, - [SMALL_STATE(1150)] = 56746, - [SMALL_STATE(1151)] = 56788, - [SMALL_STATE(1152)] = 56830, - [SMALL_STATE(1153)] = 56872, - [SMALL_STATE(1154)] = 56914, - [SMALL_STATE(1155)] = 56956, - [SMALL_STATE(1156)] = 56998, - [SMALL_STATE(1157)] = 57040, - [SMALL_STATE(1158)] = 57082, - [SMALL_STATE(1159)] = 57122, - [SMALL_STATE(1160)] = 57162, - [SMALL_STATE(1161)] = 57202, - [SMALL_STATE(1162)] = 57242, - [SMALL_STATE(1163)] = 57284, - [SMALL_STATE(1164)] = 57326, - [SMALL_STATE(1165)] = 57368, - [SMALL_STATE(1166)] = 57410, - [SMALL_STATE(1167)] = 57452, - [SMALL_STATE(1168)] = 57494, - [SMALL_STATE(1169)] = 57536, - [SMALL_STATE(1170)] = 57578, - [SMALL_STATE(1171)] = 57620, - [SMALL_STATE(1172)] = 57662, - [SMALL_STATE(1173)] = 57740, - [SMALL_STATE(1174)] = 57782, - [SMALL_STATE(1175)] = 57824, - [SMALL_STATE(1176)] = 57866, - [SMALL_STATE(1177)] = 57908, - [SMALL_STATE(1178)] = 57950, - [SMALL_STATE(1179)] = 57992, - [SMALL_STATE(1180)] = 58034, - [SMALL_STATE(1181)] = 58076, - [SMALL_STATE(1182)] = 58118, - [SMALL_STATE(1183)] = 58160, - [SMALL_STATE(1184)] = 58202, - [SMALL_STATE(1185)] = 58244, - [SMALL_STATE(1186)] = 58284, - [SMALL_STATE(1187)] = 58324, - [SMALL_STATE(1188)] = 58364, - [SMALL_STATE(1189)] = 58404, - [SMALL_STATE(1190)] = 58444, - [SMALL_STATE(1191)] = 58484, - [SMALL_STATE(1192)] = 58524, - [SMALL_STATE(1193)] = 58564, - [SMALL_STATE(1194)] = 58604, - [SMALL_STATE(1195)] = 58646, - [SMALL_STATE(1196)] = 58688, - [SMALL_STATE(1197)] = 58730, - [SMALL_STATE(1198)] = 58772, - [SMALL_STATE(1199)] = 58814, - [SMALL_STATE(1200)] = 58856, - [SMALL_STATE(1201)] = 58898, - [SMALL_STATE(1202)] = 58940, - [SMALL_STATE(1203)] = 58982, - [SMALL_STATE(1204)] = 59024, - [SMALL_STATE(1205)] = 59064, - [SMALL_STATE(1206)] = 59104, - [SMALL_STATE(1207)] = 59182, - [SMALL_STATE(1208)] = 59224, - [SMALL_STATE(1209)] = 59264, - [SMALL_STATE(1210)] = 59304, - [SMALL_STATE(1211)] = 59344, - [SMALL_STATE(1212)] = 59384, - [SMALL_STATE(1213)] = 59424, - [SMALL_STATE(1214)] = 59464, - [SMALL_STATE(1215)] = 59504, - [SMALL_STATE(1216)] = 59544, - [SMALL_STATE(1217)] = 59584, - [SMALL_STATE(1218)] = 59624, - [SMALL_STATE(1219)] = 59664, - [SMALL_STATE(1220)] = 59704, - [SMALL_STATE(1221)] = 59744, - [SMALL_STATE(1222)] = 59784, - [SMALL_STATE(1223)] = 59824, - [SMALL_STATE(1224)] = 59864, - [SMALL_STATE(1225)] = 59904, - [SMALL_STATE(1226)] = 59944, - [SMALL_STATE(1227)] = 59984, - [SMALL_STATE(1228)] = 60024, - [SMALL_STATE(1229)] = 60066, - [SMALL_STATE(1230)] = 60106, - [SMALL_STATE(1231)] = 60146, - [SMALL_STATE(1232)] = 60186, - [SMALL_STATE(1233)] = 60226, - [SMALL_STATE(1234)] = 60266, - [SMALL_STATE(1235)] = 60306, - [SMALL_STATE(1236)] = 60346, - [SMALL_STATE(1237)] = 60388, - [SMALL_STATE(1238)] = 60428, - [SMALL_STATE(1239)] = 60468, - [SMALL_STATE(1240)] = 60508, - [SMALL_STATE(1241)] = 60548, - [SMALL_STATE(1242)] = 60588, - [SMALL_STATE(1243)] = 60628, - [SMALL_STATE(1244)] = 60668, - [SMALL_STATE(1245)] = 60708, - [SMALL_STATE(1246)] = 60748, - [SMALL_STATE(1247)] = 60788, - [SMALL_STATE(1248)] = 60830, - [SMALL_STATE(1249)] = 60870, - [SMALL_STATE(1250)] = 60910, - [SMALL_STATE(1251)] = 60950, - [SMALL_STATE(1252)] = 60992, - [SMALL_STATE(1253)] = 61070, - [SMALL_STATE(1254)] = 61110, - [SMALL_STATE(1255)] = 61150, - [SMALL_STATE(1256)] = 61190, - [SMALL_STATE(1257)] = 61230, - [SMALL_STATE(1258)] = 61270, - [SMALL_STATE(1259)] = 61310, - [SMALL_STATE(1260)] = 61350, - [SMALL_STATE(1261)] = 61390, - [SMALL_STATE(1262)] = 61432, - [SMALL_STATE(1263)] = 61472, - [SMALL_STATE(1264)] = 61512, - [SMALL_STATE(1265)] = 61552, - [SMALL_STATE(1266)] = 61592, - [SMALL_STATE(1267)] = 61632, - [SMALL_STATE(1268)] = 61672, - [SMALL_STATE(1269)] = 61712, - [SMALL_STATE(1270)] = 61752, - [SMALL_STATE(1271)] = 61792, - [SMALL_STATE(1272)] = 61832, - [SMALL_STATE(1273)] = 61872, - [SMALL_STATE(1274)] = 61912, - [SMALL_STATE(1275)] = 61952, - [SMALL_STATE(1276)] = 61992, - [SMALL_STATE(1277)] = 62034, - [SMALL_STATE(1278)] = 62074, - [SMALL_STATE(1279)] = 62116, - [SMALL_STATE(1280)] = 62158, - [SMALL_STATE(1281)] = 62198, - [SMALL_STATE(1282)] = 62238, - [SMALL_STATE(1283)] = 62278, - [SMALL_STATE(1284)] = 62318, - [SMALL_STATE(1285)] = 62358, - [SMALL_STATE(1286)] = 62398, - [SMALL_STATE(1287)] = 62438, - [SMALL_STATE(1288)] = 62480, - [SMALL_STATE(1289)] = 62520, - [SMALL_STATE(1290)] = 62560, - [SMALL_STATE(1291)] = 62600, - [SMALL_STATE(1292)] = 62642, - [SMALL_STATE(1293)] = 62684, - [SMALL_STATE(1294)] = 62724, - [SMALL_STATE(1295)] = 62766, - [SMALL_STATE(1296)] = 62806, - [SMALL_STATE(1297)] = 62846, - [SMALL_STATE(1298)] = 62886, - [SMALL_STATE(1299)] = 62926, - [SMALL_STATE(1300)] = 62966, - [SMALL_STATE(1301)] = 63006, - [SMALL_STATE(1302)] = 63046, - [SMALL_STATE(1303)] = 63086, - [SMALL_STATE(1304)] = 63126, - [SMALL_STATE(1305)] = 63166, - [SMALL_STATE(1306)] = 63206, - [SMALL_STATE(1307)] = 63246, - [SMALL_STATE(1308)] = 63286, - [SMALL_STATE(1309)] = 63326, - [SMALL_STATE(1310)] = 63366, - [SMALL_STATE(1311)] = 63406, - [SMALL_STATE(1312)] = 63446, - [SMALL_STATE(1313)] = 63486, - [SMALL_STATE(1314)] = 63526, - [SMALL_STATE(1315)] = 63566, - [SMALL_STATE(1316)] = 63606, - [SMALL_STATE(1317)] = 63646, - [SMALL_STATE(1318)] = 63686, - [SMALL_STATE(1319)] = 63726, - [SMALL_STATE(1320)] = 63766, - [SMALL_STATE(1321)] = 63806, - [SMALL_STATE(1322)] = 63846, - [SMALL_STATE(1323)] = 63886, - [SMALL_STATE(1324)] = 63926, - [SMALL_STATE(1325)] = 63968, - [SMALL_STATE(1326)] = 64008, - [SMALL_STATE(1327)] = 64048, - [SMALL_STATE(1328)] = 64088, - [SMALL_STATE(1329)] = 64128, - [SMALL_STATE(1330)] = 64168, - [SMALL_STATE(1331)] = 64208, - [SMALL_STATE(1332)] = 64248, - [SMALL_STATE(1333)] = 64288, - [SMALL_STATE(1334)] = 64328, - [SMALL_STATE(1335)] = 64370, - [SMALL_STATE(1336)] = 64410, - [SMALL_STATE(1337)] = 64450, - [SMALL_STATE(1338)] = 64490, - [SMALL_STATE(1339)] = 64530, - [SMALL_STATE(1340)] = 64572, - [SMALL_STATE(1341)] = 64612, - [SMALL_STATE(1342)] = 64652, - [SMALL_STATE(1343)] = 64692, - [SMALL_STATE(1344)] = 64732, - [SMALL_STATE(1345)] = 64772, - [SMALL_STATE(1346)] = 64812, - [SMALL_STATE(1347)] = 64852, - [SMALL_STATE(1348)] = 64892, - [SMALL_STATE(1349)] = 64932, - [SMALL_STATE(1350)] = 64972, - [SMALL_STATE(1351)] = 65012, - [SMALL_STATE(1352)] = 65052, - [SMALL_STATE(1353)] = 65092, - [SMALL_STATE(1354)] = 65132, - [SMALL_STATE(1355)] = 65172, - [SMALL_STATE(1356)] = 65212, - [SMALL_STATE(1357)] = 65252, - [SMALL_STATE(1358)] = 65292, - [SMALL_STATE(1359)] = 65332, - [SMALL_STATE(1360)] = 65372, - [SMALL_STATE(1361)] = 65412, - [SMALL_STATE(1362)] = 65452, - [SMALL_STATE(1363)] = 65492, - [SMALL_STATE(1364)] = 65534, - [SMALL_STATE(1365)] = 65574, - [SMALL_STATE(1366)] = 65614, - [SMALL_STATE(1367)] = 65654, - [SMALL_STATE(1368)] = 65694, - [SMALL_STATE(1369)] = 65734, - [SMALL_STATE(1370)] = 65774, - [SMALL_STATE(1371)] = 65814, - [SMALL_STATE(1372)] = 65854, - [SMALL_STATE(1373)] = 65894, - [SMALL_STATE(1374)] = 65972, - [SMALL_STATE(1375)] = 66014, - [SMALL_STATE(1376)] = 66054, - [SMALL_STATE(1377)] = 66094, - [SMALL_STATE(1378)] = 66134, - [SMALL_STATE(1379)] = 66174, - [SMALL_STATE(1380)] = 66214, - [SMALL_STATE(1381)] = 66254, - [SMALL_STATE(1382)] = 66294, - [SMALL_STATE(1383)] = 66334, - [SMALL_STATE(1384)] = 66374, - [SMALL_STATE(1385)] = 66414, - [SMALL_STATE(1386)] = 66454, - [SMALL_STATE(1387)] = 66494, - [SMALL_STATE(1388)] = 66534, - [SMALL_STATE(1389)] = 66574, - [SMALL_STATE(1390)] = 66614, - [SMALL_STATE(1391)] = 66654, - [SMALL_STATE(1392)] = 66694, - [SMALL_STATE(1393)] = 66734, - [SMALL_STATE(1394)] = 66774, - [SMALL_STATE(1395)] = 66814, - [SMALL_STATE(1396)] = 66887, - [SMALL_STATE(1397)] = 66959, - [SMALL_STATE(1398)] = 66995, - [SMALL_STATE(1399)] = 67067, - [SMALL_STATE(1400)] = 67139, - [SMALL_STATE(1401)] = 67211, - [SMALL_STATE(1402)] = 67247, - [SMALL_STATE(1403)] = 67319, - [SMALL_STATE(1404)] = 67355, - [SMALL_STATE(1405)] = 67391, - [SMALL_STATE(1406)] = 67427, - [SMALL_STATE(1407)] = 67499, - [SMALL_STATE(1408)] = 67571, - [SMALL_STATE(1409)] = 67643, - [SMALL_STATE(1410)] = 67715, - [SMALL_STATE(1411)] = 67787, - [SMALL_STATE(1412)] = 67856, - [SMALL_STATE(1413)] = 67923, - [SMALL_STATE(1414)] = 67992, - [SMALL_STATE(1415)] = 68061, - [SMALL_STATE(1416)] = 68130, - [SMALL_STATE(1417)] = 68199, - [SMALL_STATE(1418)] = 68268, - [SMALL_STATE(1419)] = 68337, - [SMALL_STATE(1420)] = 68406, - [SMALL_STATE(1421)] = 68475, - [SMALL_STATE(1422)] = 68544, - [SMALL_STATE(1423)] = 68613, - [SMALL_STATE(1424)] = 68682, - [SMALL_STATE(1425)] = 68751, - [SMALL_STATE(1426)] = 68820, - [SMALL_STATE(1427)] = 68889, - [SMALL_STATE(1428)] = 68958, - [SMALL_STATE(1429)] = 69027, - [SMALL_STATE(1430)] = 69096, - [SMALL_STATE(1431)] = 69165, - [SMALL_STATE(1432)] = 69234, - [SMALL_STATE(1433)] = 69276, - [SMALL_STATE(1434)] = 69340, - [SMALL_STATE(1435)] = 69382, - [SMALL_STATE(1436)] = 69424, - [SMALL_STATE(1437)] = 69466, - [SMALL_STATE(1438)] = 69508, - [SMALL_STATE(1439)] = 69568, - [SMALL_STATE(1440)] = 69632, - [SMALL_STATE(1441)] = 69674, - [SMALL_STATE(1442)] = 69716, - [SMALL_STATE(1443)] = 69758, - [SMALL_STATE(1444)] = 69800, - [SMALL_STATE(1445)] = 69842, - [SMALL_STATE(1446)] = 69884, - [SMALL_STATE(1447)] = 69944, - [SMALL_STATE(1448)] = 70007, - [SMALL_STATE(1449)] = 70070, - [SMALL_STATE(1450)] = 70133, - [SMALL_STATE(1451)] = 70196, - [SMALL_STATE(1452)] = 70259, - [SMALL_STATE(1453)] = 70322, - [SMALL_STATE(1454)] = 70385, - [SMALL_STATE(1455)] = 70448, - [SMALL_STATE(1456)] = 70511, - [SMALL_STATE(1457)] = 70574, - [SMALL_STATE(1458)] = 70637, - [SMALL_STATE(1459)] = 70700, - [SMALL_STATE(1460)] = 70763, - [SMALL_STATE(1461)] = 70826, - [SMALL_STATE(1462)] = 70889, - [SMALL_STATE(1463)] = 70952, - [SMALL_STATE(1464)] = 71015, - [SMALL_STATE(1465)] = 71078, - [SMALL_STATE(1466)] = 71141, - [SMALL_STATE(1467)] = 71204, - [SMALL_STATE(1468)] = 71267, - [SMALL_STATE(1469)] = 71330, - [SMALL_STATE(1470)] = 71393, - [SMALL_STATE(1471)] = 71456, - [SMALL_STATE(1472)] = 71519, - [SMALL_STATE(1473)] = 71582, - [SMALL_STATE(1474)] = 71645, - [SMALL_STATE(1475)] = 71708, - [SMALL_STATE(1476)] = 71771, - [SMALL_STATE(1477)] = 71834, - [SMALL_STATE(1478)] = 71897, - [SMALL_STATE(1479)] = 71960, - [SMALL_STATE(1480)] = 72023, - [SMALL_STATE(1481)] = 72086, - [SMALL_STATE(1482)] = 72149, - [SMALL_STATE(1483)] = 72212, - [SMALL_STATE(1484)] = 72275, - [SMALL_STATE(1485)] = 72338, - [SMALL_STATE(1486)] = 72401, - [SMALL_STATE(1487)] = 72464, - [SMALL_STATE(1488)] = 72527, - [SMALL_STATE(1489)] = 72586, - [SMALL_STATE(1490)] = 72649, - [SMALL_STATE(1491)] = 72712, - [SMALL_STATE(1492)] = 72775, - [SMALL_STATE(1493)] = 72838, - [SMALL_STATE(1494)] = 72901, - [SMALL_STATE(1495)] = 72964, - [SMALL_STATE(1496)] = 73027, - [SMALL_STATE(1497)] = 73090, - [SMALL_STATE(1498)] = 73153, - [SMALL_STATE(1499)] = 73216, - [SMALL_STATE(1500)] = 73279, - [SMALL_STATE(1501)] = 73342, - [SMALL_STATE(1502)] = 73405, - [SMALL_STATE(1503)] = 73468, - [SMALL_STATE(1504)] = 73531, - [SMALL_STATE(1505)] = 73594, - [SMALL_STATE(1506)] = 73657, - [SMALL_STATE(1507)] = 73720, - [SMALL_STATE(1508)] = 73783, - [SMALL_STATE(1509)] = 73846, - [SMALL_STATE(1510)] = 73909, - [SMALL_STATE(1511)] = 73972, - [SMALL_STATE(1512)] = 74035, - [SMALL_STATE(1513)] = 74098, - [SMALL_STATE(1514)] = 74161, - [SMALL_STATE(1515)] = 74224, - [SMALL_STATE(1516)] = 74287, - [SMALL_STATE(1517)] = 74350, - [SMALL_STATE(1518)] = 74413, - [SMALL_STATE(1519)] = 74472, - [SMALL_STATE(1520)] = 74510, - [SMALL_STATE(1521)] = 74566, - [SMALL_STATE(1522)] = 74624, - [SMALL_STATE(1523)] = 74680, - [SMALL_STATE(1524)] = 74738, - [SMALL_STATE(1525)] = 74794, - [SMALL_STATE(1526)] = 74852, - [SMALL_STATE(1527)] = 74910, - [SMALL_STATE(1528)] = 74968, - [SMALL_STATE(1529)] = 75026, - [SMALL_STATE(1530)] = 75084, - [SMALL_STATE(1531)] = 75140, - [SMALL_STATE(1532)] = 75193, - [SMALL_STATE(1533)] = 75246, - [SMALL_STATE(1534)] = 75278, - [SMALL_STATE(1535)] = 75324, - [SMALL_STATE(1536)] = 75378, - [SMALL_STATE(1537)] = 75410, - [SMALL_STATE(1538)] = 75442, - [SMALL_STATE(1539)] = 75484, - [SMALL_STATE(1540)] = 75530, - [SMALL_STATE(1541)] = 75584, - [SMALL_STATE(1542)] = 75638, - [SMALL_STATE(1543)] = 75692, - [SMALL_STATE(1544)] = 75739, - [SMALL_STATE(1545)] = 75790, - [SMALL_STATE(1546)] = 75837, - [SMALL_STATE(1547)] = 75884, - [SMALL_STATE(1548)] = 75931, - [SMALL_STATE(1549)] = 75978, - [SMALL_STATE(1550)] = 76025, - [SMALL_STATE(1551)] = 76076, - [SMALL_STATE(1552)] = 76123, - [SMALL_STATE(1553)] = 76170, - [SMALL_STATE(1554)] = 76217, - [SMALL_STATE(1555)] = 76264, - [SMALL_STATE(1556)] = 76311, - [SMALL_STATE(1557)] = 76358, - [SMALL_STATE(1558)] = 76405, - [SMALL_STATE(1559)] = 76452, - [SMALL_STATE(1560)] = 76499, - [SMALL_STATE(1561)] = 76544, - [SMALL_STATE(1562)] = 76591, - [SMALL_STATE(1563)] = 76638, - [SMALL_STATE(1564)] = 76685, - [SMALL_STATE(1565)] = 76732, - [SMALL_STATE(1566)] = 76779, - [SMALL_STATE(1567)] = 76819, - [SMALL_STATE(1568)] = 76867, - [SMALL_STATE(1569)] = 76899, - [SMALL_STATE(1570)] = 76931, - [SMALL_STATE(1571)] = 76979, - [SMALL_STATE(1572)] = 77015, - [SMALL_STATE(1573)] = 77063, - [SMALL_STATE(1574)] = 77099, - [SMALL_STATE(1575)] = 77147, - [SMALL_STATE(1576)] = 77176, - [SMALL_STATE(1577)] = 77211, - [SMALL_STATE(1578)] = 77254, - [SMALL_STATE(1579)] = 77299, - [SMALL_STATE(1580)] = 77344, - [SMALL_STATE(1581)] = 77373, - [SMALL_STATE(1582)] = 77408, - [SMALL_STATE(1583)] = 77441, - [SMALL_STATE(1584)] = 77486, - [SMALL_STATE(1585)] = 77531, - [SMALL_STATE(1586)] = 77576, - [SMALL_STATE(1587)] = 77621, - [SMALL_STATE(1588)] = 77664, - [SMALL_STATE(1589)] = 77710, - [SMALL_STATE(1590)] = 77756, - [SMALL_STATE(1591)] = 77802, - [SMALL_STATE(1592)] = 77844, - [SMALL_STATE(1593)] = 77874, - [SMALL_STATE(1594)] = 77916, - [SMALL_STATE(1595)] = 77958, - [SMALL_STATE(1596)] = 77990, - [SMALL_STATE(1597)] = 78020, - [SMALL_STATE(1598)] = 78048, - [SMALL_STATE(1599)] = 78086, - [SMALL_STATE(1600)] = 78132, - [SMALL_STATE(1601)] = 78166, - [SMALL_STATE(1602)] = 78208, - [SMALL_STATE(1603)] = 78254, - [SMALL_STATE(1604)] = 78296, - [SMALL_STATE(1605)] = 78334, - [SMALL_STATE(1606)] = 78364, - [SMALL_STATE(1607)] = 78410, - [SMALL_STATE(1608)] = 78456, - [SMALL_STATE(1609)] = 78498, - [SMALL_STATE(1610)] = 78536, - [SMALL_STATE(1611)] = 78582, - [SMALL_STATE(1612)] = 78629, - [SMALL_STATE(1613)] = 78676, - [SMALL_STATE(1614)] = 78723, - [SMALL_STATE(1615)] = 78750, - [SMALL_STATE(1616)] = 78789, - [SMALL_STATE(1617)] = 78836, - [SMALL_STATE(1618)] = 78883, - [SMALL_STATE(1619)] = 78922, - [SMALL_STATE(1620)] = 78951, - [SMALL_STATE(1621)] = 78978, - [SMALL_STATE(1622)] = 79007, - [SMALL_STATE(1623)] = 79036, - [SMALL_STATE(1624)] = 79073, - [SMALL_STATE(1625)] = 79110, - [SMALL_STATE(1626)] = 79157, - [SMALL_STATE(1627)] = 79204, - [SMALL_STATE(1628)] = 79233, - [SMALL_STATE(1629)] = 79280, - [SMALL_STATE(1630)] = 79327, - [SMALL_STATE(1631)] = 79356, - [SMALL_STATE(1632)] = 79403, - [SMALL_STATE(1633)] = 79450, - [SMALL_STATE(1634)] = 79497, - [SMALL_STATE(1635)] = 79544, - [SMALL_STATE(1636)] = 79591, - [SMALL_STATE(1637)] = 79638, - [SMALL_STATE(1638)] = 79677, - [SMALL_STATE(1639)] = 79708, - [SMALL_STATE(1640)] = 79737, - [SMALL_STATE(1641)] = 79784, - [SMALL_STATE(1642)] = 79811, - [SMALL_STATE(1643)] = 79858, - [SMALL_STATE(1644)] = 79887, - [SMALL_STATE(1645)] = 79934, - [SMALL_STATE(1646)] = 79981, - [SMALL_STATE(1647)] = 80028, - [SMALL_STATE(1648)] = 80075, - [SMALL_STATE(1649)] = 80110, - [SMALL_STATE(1650)] = 80157, - [SMALL_STATE(1651)] = 80204, - [SMALL_STATE(1652)] = 80251, - [SMALL_STATE(1653)] = 80280, - [SMALL_STATE(1654)] = 80327, - [SMALL_STATE(1655)] = 80366, - [SMALL_STATE(1656)] = 80413, - [SMALL_STATE(1657)] = 80460, - [SMALL_STATE(1658)] = 80507, - [SMALL_STATE(1659)] = 80554, - [SMALL_STATE(1660)] = 80601, - [SMALL_STATE(1661)] = 80648, - [SMALL_STATE(1662)] = 80687, - [SMALL_STATE(1663)] = 80716, - [SMALL_STATE(1664)] = 80763, - [SMALL_STATE(1665)] = 80810, - [SMALL_STATE(1666)] = 80857, - [SMALL_STATE(1667)] = 80904, - [SMALL_STATE(1668)] = 80951, - [SMALL_STATE(1669)] = 80988, - [SMALL_STATE(1670)] = 81035, - [SMALL_STATE(1671)] = 81082, - [SMALL_STATE(1672)] = 81129, - [SMALL_STATE(1673)] = 81166, - [SMALL_STATE(1674)] = 81213, - [SMALL_STATE(1675)] = 81260, - [SMALL_STATE(1676)] = 81307, - [SMALL_STATE(1677)] = 81346, - [SMALL_STATE(1678)] = 81385, - [SMALL_STATE(1679)] = 81432, - [SMALL_STATE(1680)] = 81479, - [SMALL_STATE(1681)] = 81526, - [SMALL_STATE(1682)] = 81573, - [SMALL_STATE(1683)] = 81602, - [SMALL_STATE(1684)] = 81631, - [SMALL_STATE(1685)] = 81658, - [SMALL_STATE(1686)] = 81705, - [SMALL_STATE(1687)] = 81752, - [SMALL_STATE(1688)] = 81787, - [SMALL_STATE(1689)] = 81814, - [SMALL_STATE(1690)] = 81843, - [SMALL_STATE(1691)] = 81890, - [SMALL_STATE(1692)] = 81937, - [SMALL_STATE(1693)] = 81976, - [SMALL_STATE(1694)] = 82018, - [SMALL_STATE(1695)] = 82052, - [SMALL_STATE(1696)] = 82088, - [SMALL_STATE(1697)] = 82124, - [SMALL_STATE(1698)] = 82166, - [SMALL_STATE(1699)] = 82208, - [SMALL_STATE(1700)] = 82240, - [SMALL_STATE(1701)] = 82276, - [SMALL_STATE(1702)] = 82312, - [SMALL_STATE(1703)] = 82342, - [SMALL_STATE(1704)] = 82368, - [SMALL_STATE(1705)] = 82408, - [SMALL_STATE(1706)] = 82450, - [SMALL_STATE(1707)] = 82478, - [SMALL_STATE(1708)] = 82514, - [SMALL_STATE(1709)] = 82540, - [SMALL_STATE(1710)] = 82582, - [SMALL_STATE(1711)] = 82612, - [SMALL_STATE(1712)] = 82646, - [SMALL_STATE(1713)] = 82672, - [SMALL_STATE(1714)] = 82708, - [SMALL_STATE(1715)] = 82748, - [SMALL_STATE(1716)] = 82781, - [SMALL_STATE(1717)] = 82814, - [SMALL_STATE(1718)] = 82843, - [SMALL_STATE(1719)] = 82872, - [SMALL_STATE(1720)] = 82905, - [SMALL_STATE(1721)] = 82938, - [SMALL_STATE(1722)] = 82971, - [SMALL_STATE(1723)] = 83004, - [SMALL_STATE(1724)] = 83033, - [SMALL_STATE(1725)] = 83060, - [SMALL_STATE(1726)] = 83093, - [SMALL_STATE(1727)] = 83126, - [SMALL_STATE(1728)] = 83159, - [SMALL_STATE(1729)] = 83192, - [SMALL_STATE(1730)] = 83221, - [SMALL_STATE(1731)] = 83254, - [SMALL_STATE(1732)] = 83279, - [SMALL_STATE(1733)] = 83306, - [SMALL_STATE(1734)] = 83331, - [SMALL_STATE(1735)] = 83364, - [SMALL_STATE(1736)] = 83397, - [SMALL_STATE(1737)] = 83430, - [SMALL_STATE(1738)] = 83463, - [SMALL_STATE(1739)] = 83496, - [SMALL_STATE(1740)] = 83529, - [SMALL_STATE(1741)] = 83562, - [SMALL_STATE(1742)] = 83595, - [SMALL_STATE(1743)] = 83628, - [SMALL_STATE(1744)] = 83661, - [SMALL_STATE(1745)] = 83694, - [SMALL_STATE(1746)] = 83727, - [SMALL_STATE(1747)] = 83760, - [SMALL_STATE(1748)] = 83793, - [SMALL_STATE(1749)] = 83826, - [SMALL_STATE(1750)] = 83859, - [SMALL_STATE(1751)] = 83892, - [SMALL_STATE(1752)] = 83925, - [SMALL_STATE(1753)] = 83958, - [SMALL_STATE(1754)] = 83991, - [SMALL_STATE(1755)] = 84022, - [SMALL_STATE(1756)] = 84055, - [SMALL_STATE(1757)] = 84088, - [SMALL_STATE(1758)] = 84121, - [SMALL_STATE(1759)] = 84154, - [SMALL_STATE(1760)] = 84187, - [SMALL_STATE(1761)] = 84218, - [SMALL_STATE(1762)] = 84251, - [SMALL_STATE(1763)] = 84284, - [SMALL_STATE(1764)] = 84317, - [SMALL_STATE(1765)] = 84350, - [SMALL_STATE(1766)] = 84383, - [SMALL_STATE(1767)] = 84416, - [SMALL_STATE(1768)] = 84449, - [SMALL_STATE(1769)] = 84482, - [SMALL_STATE(1770)] = 84515, - [SMALL_STATE(1771)] = 84548, - [SMALL_STATE(1772)] = 84581, - [SMALL_STATE(1773)] = 84606, - [SMALL_STATE(1774)] = 84637, - [SMALL_STATE(1775)] = 84670, - [SMALL_STATE(1776)] = 84706, - [SMALL_STATE(1777)] = 84744, - [SMALL_STATE(1778)] = 84780, - [SMALL_STATE(1779)] = 84810, - [SMALL_STATE(1780)] = 84848, - [SMALL_STATE(1781)] = 84886, - [SMALL_STATE(1782)] = 84914, - [SMALL_STATE(1783)] = 84950, - [SMALL_STATE(1784)] = 84986, - [SMALL_STATE(1785)] = 85022, - [SMALL_STATE(1786)] = 85058, - [SMALL_STATE(1787)] = 85096, - [SMALL_STATE(1788)] = 85120, - [SMALL_STATE(1789)] = 85158, - [SMALL_STATE(1790)] = 85194, - [SMALL_STATE(1791)] = 85226, - [SMALL_STATE(1792)] = 85262, - [SMALL_STATE(1793)] = 85294, - [SMALL_STATE(1794)] = 85330, - [SMALL_STATE(1795)] = 85366, - [SMALL_STATE(1796)] = 85390, - [SMALL_STATE(1797)] = 85428, - [SMALL_STATE(1798)] = 85458, - [SMALL_STATE(1799)] = 85494, - [SMALL_STATE(1800)] = 85518, - [SMALL_STATE(1801)] = 85548, - [SMALL_STATE(1802)] = 85586, - [SMALL_STATE(1803)] = 85624, - [SMALL_STATE(1804)] = 85649, - [SMALL_STATE(1805)] = 85680, - [SMALL_STATE(1806)] = 85715, - [SMALL_STATE(1807)] = 85750, - [SMALL_STATE(1808)] = 85773, - [SMALL_STATE(1809)] = 85808, - [SMALL_STATE(1810)] = 85839, - [SMALL_STATE(1811)] = 85862, - [SMALL_STATE(1812)] = 85885, - [SMALL_STATE(1813)] = 85916, - [SMALL_STATE(1814)] = 85951, - [SMALL_STATE(1815)] = 85986, - [SMALL_STATE(1816)] = 86009, - [SMALL_STATE(1817)] = 86032, - [SMALL_STATE(1818)] = 86063, - [SMALL_STATE(1819)] = 86088, - [SMALL_STATE(1820)] = 86123, - [SMALL_STATE(1821)] = 86158, - [SMALL_STATE(1822)] = 86181, - [SMALL_STATE(1823)] = 86216, - [SMALL_STATE(1824)] = 86251, - [SMALL_STATE(1825)] = 86284, - [SMALL_STATE(1826)] = 86319, - [SMALL_STATE(1827)] = 86352, - [SMALL_STATE(1828)] = 86387, - [SMALL_STATE(1829)] = 86412, - [SMALL_STATE(1830)] = 86441, - [SMALL_STATE(1831)] = 86472, - [SMALL_STATE(1832)] = 86505, - [SMALL_STATE(1833)] = 86540, - [SMALL_STATE(1834)] = 86565, - [SMALL_STATE(1835)] = 86588, - [SMALL_STATE(1836)] = 86621, - [SMALL_STATE(1837)] = 86644, - [SMALL_STATE(1838)] = 86676, - [SMALL_STATE(1839)] = 86706, - [SMALL_STATE(1840)] = 86738, - [SMALL_STATE(1841)] = 86770, - [SMALL_STATE(1842)] = 86802, - [SMALL_STATE(1843)] = 86834, - [SMALL_STATE(1844)] = 86864, - [SMALL_STATE(1845)] = 86894, - [SMALL_STATE(1846)] = 86924, - [SMALL_STATE(1847)] = 86954, - [SMALL_STATE(1848)] = 86986, - [SMALL_STATE(1849)] = 87018, - [SMALL_STATE(1850)] = 87050, - [SMALL_STATE(1851)] = 87080, - [SMALL_STATE(1852)] = 87112, - [SMALL_STATE(1853)] = 87144, - [SMALL_STATE(1854)] = 87174, - [SMALL_STATE(1855)] = 87196, - [SMALL_STATE(1856)] = 87228, - [SMALL_STATE(1857)] = 87258, - [SMALL_STATE(1858)] = 87290, - [SMALL_STATE(1859)] = 87322, - [SMALL_STATE(1860)] = 87352, - [SMALL_STATE(1861)] = 87384, - [SMALL_STATE(1862)] = 87416, - [SMALL_STATE(1863)] = 87448, - [SMALL_STATE(1864)] = 87480, - [SMALL_STATE(1865)] = 87510, - [SMALL_STATE(1866)] = 87538, - [SMALL_STATE(1867)] = 87570, - [SMALL_STATE(1868)] = 87600, - [SMALL_STATE(1869)] = 87630, - [SMALL_STATE(1870)] = 87662, - [SMALL_STATE(1871)] = 87694, - [SMALL_STATE(1872)] = 87724, - [SMALL_STATE(1873)] = 87754, - [SMALL_STATE(1874)] = 87786, - [SMALL_STATE(1875)] = 87816, - [SMALL_STATE(1876)] = 87846, - [SMALL_STATE(1877)] = 87876, - [SMALL_STATE(1878)] = 87908, - [SMALL_STATE(1879)] = 87940, - [SMALL_STATE(1880)] = 87970, - [SMALL_STATE(1881)] = 88002, - [SMALL_STATE(1882)] = 88034, - [SMALL_STATE(1883)] = 88066, - [SMALL_STATE(1884)] = 88098, - [SMALL_STATE(1885)] = 88130, - [SMALL_STATE(1886)] = 88162, - [SMALL_STATE(1887)] = 88192, - [SMALL_STATE(1888)] = 88222, - [SMALL_STATE(1889)] = 88252, - [SMALL_STATE(1890)] = 88282, - [SMALL_STATE(1891)] = 88314, - [SMALL_STATE(1892)] = 88346, - [SMALL_STATE(1893)] = 88378, - [SMALL_STATE(1894)] = 88406, - [SMALL_STATE(1895)] = 88428, - [SMALL_STATE(1896)] = 88460, - [SMALL_STATE(1897)] = 88490, - [SMALL_STATE(1898)] = 88520, - [SMALL_STATE(1899)] = 88552, - [SMALL_STATE(1900)] = 88584, - [SMALL_STATE(1901)] = 88616, - [SMALL_STATE(1902)] = 88646, - [SMALL_STATE(1903)] = 88678, - [SMALL_STATE(1904)] = 88710, - [SMALL_STATE(1905)] = 88742, - [SMALL_STATE(1906)] = 88772, - [SMALL_STATE(1907)] = 88804, - [SMALL_STATE(1908)] = 88834, - [SMALL_STATE(1909)] = 88866, - [SMALL_STATE(1910)] = 88896, - [SMALL_STATE(1911)] = 88926, - [SMALL_STATE(1912)] = 88956, - [SMALL_STATE(1913)] = 88988, - [SMALL_STATE(1914)] = 89020, - [SMALL_STATE(1915)] = 89050, - [SMALL_STATE(1916)] = 89080, - [SMALL_STATE(1917)] = 89110, - [SMALL_STATE(1918)] = 89142, - [SMALL_STATE(1919)] = 89174, - [SMALL_STATE(1920)] = 89206, - [SMALL_STATE(1921)] = 89236, - [SMALL_STATE(1922)] = 89268, - [SMALL_STATE(1923)] = 89290, - [SMALL_STATE(1924)] = 89312, - [SMALL_STATE(1925)] = 89344, - [SMALL_STATE(1926)] = 89366, - [SMALL_STATE(1927)] = 89398, - [SMALL_STATE(1928)] = 89430, - [SMALL_STATE(1929)] = 89460, - [SMALL_STATE(1930)] = 89488, - [SMALL_STATE(1931)] = 89518, - [SMALL_STATE(1932)] = 89550, - [SMALL_STATE(1933)] = 89580, - [SMALL_STATE(1934)] = 89612, - [SMALL_STATE(1935)] = 89644, - [SMALL_STATE(1936)] = 89674, - [SMALL_STATE(1937)] = 89706, - [SMALL_STATE(1938)] = 89736, - [SMALL_STATE(1939)] = 89768, - [SMALL_STATE(1940)] = 89800, - [SMALL_STATE(1941)] = 89832, - [SMALL_STATE(1942)] = 89864, - [SMALL_STATE(1943)] = 89896, - [SMALL_STATE(1944)] = 89928, - [SMALL_STATE(1945)] = 89958, - [SMALL_STATE(1946)] = 89990, - [SMALL_STATE(1947)] = 90017, - [SMALL_STATE(1948)] = 90046, - [SMALL_STATE(1949)] = 90075, - [SMALL_STATE(1950)] = 90100, - [SMALL_STATE(1951)] = 90125, - [SMALL_STATE(1952)] = 90154, - [SMALL_STATE(1953)] = 90183, - [SMALL_STATE(1954)] = 90212, - [SMALL_STATE(1955)] = 90241, - [SMALL_STATE(1956)] = 90270, - [SMALL_STATE(1957)] = 90299, - [SMALL_STATE(1958)] = 90328, - [SMALL_STATE(1959)] = 90357, - [SMALL_STATE(1960)] = 90382, - [SMALL_STATE(1961)] = 90411, - [SMALL_STATE(1962)] = 90436, - [SMALL_STATE(1963)] = 90457, - [SMALL_STATE(1964)] = 90486, - [SMALL_STATE(1965)] = 90515, - [SMALL_STATE(1966)] = 90544, - [SMALL_STATE(1967)] = 90573, - [SMALL_STATE(1968)] = 90602, - [SMALL_STATE(1969)] = 90631, - [SMALL_STATE(1970)] = 90656, - [SMALL_STATE(1971)] = 90683, - [SMALL_STATE(1972)] = 90712, - [SMALL_STATE(1973)] = 90741, - [SMALL_STATE(1974)] = 90770, - [SMALL_STATE(1975)] = 90795, - [SMALL_STATE(1976)] = 90824, - [SMALL_STATE(1977)] = 90851, - [SMALL_STATE(1978)] = 90880, - [SMALL_STATE(1979)] = 90909, - [SMALL_STATE(1980)] = 90938, - [SMALL_STATE(1981)] = 90967, - [SMALL_STATE(1982)] = 90996, - [SMALL_STATE(1983)] = 91025, - [SMALL_STATE(1984)] = 91054, - [SMALL_STATE(1985)] = 91081, - [SMALL_STATE(1986)] = 91110, - [SMALL_STATE(1987)] = 91139, - [SMALL_STATE(1988)] = 91168, - [SMALL_STATE(1989)] = 91197, - [SMALL_STATE(1990)] = 91226, - [SMALL_STATE(1991)] = 91255, - [SMALL_STATE(1992)] = 91280, - [SMALL_STATE(1993)] = 91305, - [SMALL_STATE(1994)] = 91328, - [SMALL_STATE(1995)] = 91355, - [SMALL_STATE(1996)] = 91384, - [SMALL_STATE(1997)] = 91413, - [SMALL_STATE(1998)] = 91438, - [SMALL_STATE(1999)] = 91467, - [SMALL_STATE(2000)] = 91496, - [SMALL_STATE(2001)] = 91525, - [SMALL_STATE(2002)] = 91554, - [SMALL_STATE(2003)] = 91575, - [SMALL_STATE(2004)] = 91602, - [SMALL_STATE(2005)] = 91631, - [SMALL_STATE(2006)] = 91660, - [SMALL_STATE(2007)] = 91689, - [SMALL_STATE(2008)] = 91718, - [SMALL_STATE(2009)] = 91747, - [SMALL_STATE(2010)] = 91776, - [SMALL_STATE(2011)] = 91805, - [SMALL_STATE(2012)] = 91834, - [SMALL_STATE(2013)] = 91863, - [SMALL_STATE(2014)] = 91890, - [SMALL_STATE(2015)] = 91919, - [SMALL_STATE(2016)] = 91948, - [SMALL_STATE(2017)] = 91977, - [SMALL_STATE(2018)] = 92006, - [SMALL_STATE(2019)] = 92035, - [SMALL_STATE(2020)] = 92064, - [SMALL_STATE(2021)] = 92093, - [SMALL_STATE(2022)] = 92122, - [SMALL_STATE(2023)] = 92151, - [SMALL_STATE(2024)] = 92180, - [SMALL_STATE(2025)] = 92209, - [SMALL_STATE(2026)] = 92238, - [SMALL_STATE(2027)] = 92267, - [SMALL_STATE(2028)] = 92296, - [SMALL_STATE(2029)] = 92325, - [SMALL_STATE(2030)] = 92352, - [SMALL_STATE(2031)] = 92381, - [SMALL_STATE(2032)] = 92410, - [SMALL_STATE(2033)] = 92439, - [SMALL_STATE(2034)] = 92468, - [SMALL_STATE(2035)] = 92497, - [SMALL_STATE(2036)] = 92526, - [SMALL_STATE(2037)] = 92555, - [SMALL_STATE(2038)] = 92584, - [SMALL_STATE(2039)] = 92613, - [SMALL_STATE(2040)] = 92642, - [SMALL_STATE(2041)] = 92667, - [SMALL_STATE(2042)] = 92694, - [SMALL_STATE(2043)] = 92723, - [SMALL_STATE(2044)] = 92752, - [SMALL_STATE(2045)] = 92781, - [SMALL_STATE(2046)] = 92810, - [SMALL_STATE(2047)] = 92839, - [SMALL_STATE(2048)] = 92864, - [SMALL_STATE(2049)] = 92891, - [SMALL_STATE(2050)] = 92914, - [SMALL_STATE(2051)] = 92943, - [SMALL_STATE(2052)] = 92972, - [SMALL_STATE(2053)] = 93001, - [SMALL_STATE(2054)] = 93030, - [SMALL_STATE(2055)] = 93051, - [SMALL_STATE(2056)] = 93080, - [SMALL_STATE(2057)] = 93105, - [SMALL_STATE(2058)] = 93134, - [SMALL_STATE(2059)] = 93163, - [SMALL_STATE(2060)] = 93188, - [SMALL_STATE(2061)] = 93217, - [SMALL_STATE(2062)] = 93246, - [SMALL_STATE(2063)] = 93275, - [SMALL_STATE(2064)] = 93304, - [SMALL_STATE(2065)] = 93333, - [SMALL_STATE(2066)] = 93362, - [SMALL_STATE(2067)] = 93391, - [SMALL_STATE(2068)] = 93420, - [SMALL_STATE(2069)] = 93449, - [SMALL_STATE(2070)] = 93474, - [SMALL_STATE(2071)] = 93503, - [SMALL_STATE(2072)] = 93532, - [SMALL_STATE(2073)] = 93561, - [SMALL_STATE(2074)] = 93590, - [SMALL_STATE(2075)] = 93615, - [SMALL_STATE(2076)] = 93644, - [SMALL_STATE(2077)] = 93673, - [SMALL_STATE(2078)] = 93702, - [SMALL_STATE(2079)] = 93728, - [SMALL_STATE(2080)] = 93752, - [SMALL_STATE(2081)] = 93774, - [SMALL_STATE(2082)] = 93796, - [SMALL_STATE(2083)] = 93816, - [SMALL_STATE(2084)] = 93836, - [SMALL_STATE(2085)] = 93860, - [SMALL_STATE(2086)] = 93886, - [SMALL_STATE(2087)] = 93912, - [SMALL_STATE(2088)] = 93936, - [SMALL_STATE(2089)] = 93962, - [SMALL_STATE(2090)] = 93982, - [SMALL_STATE(2091)] = 94008, - [SMALL_STATE(2092)] = 94032, - [SMALL_STATE(2093)] = 94058, - [SMALL_STATE(2094)] = 94082, - [SMALL_STATE(2095)] = 94108, - [SMALL_STATE(2096)] = 94132, - [SMALL_STATE(2097)] = 94158, - [SMALL_STATE(2098)] = 94180, - [SMALL_STATE(2099)] = 94206, - [SMALL_STATE(2100)] = 94226, - [SMALL_STATE(2101)] = 94252, - [SMALL_STATE(2102)] = 94276, - [SMALL_STATE(2103)] = 94298, - [SMALL_STATE(2104)] = 94322, - [SMALL_STATE(2105)] = 94344, - [SMALL_STATE(2106)] = 94370, - [SMALL_STATE(2107)] = 94394, - [SMALL_STATE(2108)] = 94414, - [SMALL_STATE(2109)] = 94436, - [SMALL_STATE(2110)] = 94460, - [SMALL_STATE(2111)] = 94484, - [SMALL_STATE(2112)] = 94508, - [SMALL_STATE(2113)] = 94534, - [SMALL_STATE(2114)] = 94558, - [SMALL_STATE(2115)] = 94582, - [SMALL_STATE(2116)] = 94608, - [SMALL_STATE(2117)] = 94628, - [SMALL_STATE(2118)] = 94650, - [SMALL_STATE(2119)] = 94674, - [SMALL_STATE(2120)] = 94698, - [SMALL_STATE(2121)] = 94718, - [SMALL_STATE(2122)] = 94740, - [SMALL_STATE(2123)] = 94760, - [SMALL_STATE(2124)] = 94786, - [SMALL_STATE(2125)] = 94806, - [SMALL_STATE(2126)] = 94826, - [SMALL_STATE(2127)] = 94850, - [SMALL_STATE(2128)] = 94874, - [SMALL_STATE(2129)] = 94896, - [SMALL_STATE(2130)] = 94918, - [SMALL_STATE(2131)] = 94940, - [SMALL_STATE(2132)] = 94964, - [SMALL_STATE(2133)] = 94988, - [SMALL_STATE(2134)] = 95010, - [SMALL_STATE(2135)] = 95030, - [SMALL_STATE(2136)] = 95056, - [SMALL_STATE(2137)] = 95076, - [SMALL_STATE(2138)] = 95100, - [SMALL_STATE(2139)] = 95126, - [SMALL_STATE(2140)] = 95150, - [SMALL_STATE(2141)] = 95170, - [SMALL_STATE(2142)] = 95190, - [SMALL_STATE(2143)] = 95216, - [SMALL_STATE(2144)] = 95240, - [SMALL_STATE(2145)] = 95264, - [SMALL_STATE(2146)] = 95288, - [SMALL_STATE(2147)] = 95308, - [SMALL_STATE(2148)] = 95328, - [SMALL_STATE(2149)] = 95354, - [SMALL_STATE(2150)] = 95380, - [SMALL_STATE(2151)] = 95400, - [SMALL_STATE(2152)] = 95420, - [SMALL_STATE(2153)] = 95446, - [SMALL_STATE(2154)] = 95470, - [SMALL_STATE(2155)] = 95490, - [SMALL_STATE(2156)] = 95514, - [SMALL_STATE(2157)] = 95540, - [SMALL_STATE(2158)] = 95566, - [SMALL_STATE(2159)] = 95586, - [SMALL_STATE(2160)] = 95610, - [SMALL_STATE(2161)] = 95634, - [SMALL_STATE(2162)] = 95654, - [SMALL_STATE(2163)] = 95680, - [SMALL_STATE(2164)] = 95702, - [SMALL_STATE(2165)] = 95724, - [SMALL_STATE(2166)] = 95750, - [SMALL_STATE(2167)] = 95774, - [SMALL_STATE(2168)] = 95798, - [SMALL_STATE(2169)] = 95822, - [SMALL_STATE(2170)] = 95848, - [SMALL_STATE(2171)] = 95868, - [SMALL_STATE(2172)] = 95890, - [SMALL_STATE(2173)] = 95912, - [SMALL_STATE(2174)] = 95932, - [SMALL_STATE(2175)] = 95956, - [SMALL_STATE(2176)] = 95982, - [SMALL_STATE(2177)] = 96006, - [SMALL_STATE(2178)] = 96030, - [SMALL_STATE(2179)] = 96056, - [SMALL_STATE(2180)] = 96082, - [SMALL_STATE(2181)] = 96105, - [SMALL_STATE(2182)] = 96124, - [SMALL_STATE(2183)] = 96147, - [SMALL_STATE(2184)] = 96170, - [SMALL_STATE(2185)] = 96193, - [SMALL_STATE(2186)] = 96216, - [SMALL_STATE(2187)] = 96239, - [SMALL_STATE(2188)] = 96262, - [SMALL_STATE(2189)] = 96285, - [SMALL_STATE(2190)] = 96308, - [SMALL_STATE(2191)] = 96331, - [SMALL_STATE(2192)] = 96354, - [SMALL_STATE(2193)] = 96377, - [SMALL_STATE(2194)] = 96400, - [SMALL_STATE(2195)] = 96423, - [SMALL_STATE(2196)] = 96446, - [SMALL_STATE(2197)] = 96469, - [SMALL_STATE(2198)] = 96492, - [SMALL_STATE(2199)] = 96515, - [SMALL_STATE(2200)] = 96536, - [SMALL_STATE(2201)] = 96559, - [SMALL_STATE(2202)] = 96582, - [SMALL_STATE(2203)] = 96605, - [SMALL_STATE(2204)] = 96628, - [SMALL_STATE(2205)] = 96651, - [SMALL_STATE(2206)] = 96674, - [SMALL_STATE(2207)] = 96697, - [SMALL_STATE(2208)] = 96720, - [SMALL_STATE(2209)] = 96743, - [SMALL_STATE(2210)] = 96766, - [SMALL_STATE(2211)] = 96789, - [SMALL_STATE(2212)] = 96812, - [SMALL_STATE(2213)] = 96835, - [SMALL_STATE(2214)] = 96854, - [SMALL_STATE(2215)] = 96877, - [SMALL_STATE(2216)] = 96900, - [SMALL_STATE(2217)] = 96923, - [SMALL_STATE(2218)] = 96944, - [SMALL_STATE(2219)] = 96967, - [SMALL_STATE(2220)] = 96986, - [SMALL_STATE(2221)] = 97009, - [SMALL_STATE(2222)] = 97032, - [SMALL_STATE(2223)] = 97055, - [SMALL_STATE(2224)] = 97078, - [SMALL_STATE(2225)] = 97101, - [SMALL_STATE(2226)] = 97124, - [SMALL_STATE(2227)] = 97147, - [SMALL_STATE(2228)] = 97170, - [SMALL_STATE(2229)] = 97193, - [SMALL_STATE(2230)] = 97216, - [SMALL_STATE(2231)] = 97235, - [SMALL_STATE(2232)] = 97258, - [SMALL_STATE(2233)] = 97279, - [SMALL_STATE(2234)] = 97302, - [SMALL_STATE(2235)] = 97323, - [SMALL_STATE(2236)] = 97346, - [SMALL_STATE(2237)] = 97369, - [SMALL_STATE(2238)] = 97392, - [SMALL_STATE(2239)] = 97415, - [SMALL_STATE(2240)] = 97438, - [SMALL_STATE(2241)] = 97457, - [SMALL_STATE(2242)] = 97480, - [SMALL_STATE(2243)] = 97503, - [SMALL_STATE(2244)] = 97526, - [SMALL_STATE(2245)] = 97549, - [SMALL_STATE(2246)] = 97572, - [SMALL_STATE(2247)] = 97595, - [SMALL_STATE(2248)] = 97618, - [SMALL_STATE(2249)] = 97641, - [SMALL_STATE(2250)] = 97664, - [SMALL_STATE(2251)] = 97687, - [SMALL_STATE(2252)] = 97710, - [SMALL_STATE(2253)] = 97733, - [SMALL_STATE(2254)] = 97754, - [SMALL_STATE(2255)] = 97777, - [SMALL_STATE(2256)] = 97800, - [SMALL_STATE(2257)] = 97823, - [SMALL_STATE(2258)] = 97846, - [SMALL_STATE(2259)] = 97869, - [SMALL_STATE(2260)] = 97892, - [SMALL_STATE(2261)] = 97915, - [SMALL_STATE(2262)] = 97938, - [SMALL_STATE(2263)] = 97957, - [SMALL_STATE(2264)] = 97980, - [SMALL_STATE(2265)] = 98003, - [SMALL_STATE(2266)] = 98026, - [SMALL_STATE(2267)] = 98049, - [SMALL_STATE(2268)] = 98072, - [SMALL_STATE(2269)] = 98095, - [SMALL_STATE(2270)] = 98118, - [SMALL_STATE(2271)] = 98141, - [SMALL_STATE(2272)] = 98164, - [SMALL_STATE(2273)] = 98187, - [SMALL_STATE(2274)] = 98210, - [SMALL_STATE(2275)] = 98233, - [SMALL_STATE(2276)] = 98256, - [SMALL_STATE(2277)] = 98279, - [SMALL_STATE(2278)] = 98302, - [SMALL_STATE(2279)] = 98325, - [SMALL_STATE(2280)] = 98344, - [SMALL_STATE(2281)] = 98367, - [SMALL_STATE(2282)] = 98390, - [SMALL_STATE(2283)] = 98413, - [SMALL_STATE(2284)] = 98432, - [SMALL_STATE(2285)] = 98455, - [SMALL_STATE(2286)] = 98478, - [SMALL_STATE(2287)] = 98501, - [SMALL_STATE(2288)] = 98522, - [SMALL_STATE(2289)] = 98545, - [SMALL_STATE(2290)] = 98568, - [SMALL_STATE(2291)] = 98591, - [SMALL_STATE(2292)] = 98614, - [SMALL_STATE(2293)] = 98633, - [SMALL_STATE(2294)] = 98656, - [SMALL_STATE(2295)] = 98679, - [SMALL_STATE(2296)] = 98702, - [SMALL_STATE(2297)] = 98723, - [SMALL_STATE(2298)] = 98746, - [SMALL_STATE(2299)] = 98769, - [SMALL_STATE(2300)] = 98792, - [SMALL_STATE(2301)] = 98815, - [SMALL_STATE(2302)] = 98838, - [SMALL_STATE(2303)] = 98861, - [SMALL_STATE(2304)] = 98884, - [SMALL_STATE(2305)] = 98907, - [SMALL_STATE(2306)] = 98930, - [SMALL_STATE(2307)] = 98953, - [SMALL_STATE(2308)] = 98976, - [SMALL_STATE(2309)] = 98999, - [SMALL_STATE(2310)] = 99020, - [SMALL_STATE(2311)] = 99043, - [SMALL_STATE(2312)] = 99066, - [SMALL_STATE(2313)] = 99089, - [SMALL_STATE(2314)] = 99108, - [SMALL_STATE(2315)] = 99127, - [SMALL_STATE(2316)] = 99150, - [SMALL_STATE(2317)] = 99169, - [SMALL_STATE(2318)] = 99192, - [SMALL_STATE(2319)] = 99213, - [SMALL_STATE(2320)] = 99236, - [SMALL_STATE(2321)] = 99259, - [SMALL_STATE(2322)] = 99282, - [SMALL_STATE(2323)] = 99301, - [SMALL_STATE(2324)] = 99324, - [SMALL_STATE(2325)] = 99347, - [SMALL_STATE(2326)] = 99370, - [SMALL_STATE(2327)] = 99389, - [SMALL_STATE(2328)] = 99412, - [SMALL_STATE(2329)] = 99431, - [SMALL_STATE(2330)] = 99454, - [SMALL_STATE(2331)] = 99477, - [SMALL_STATE(2332)] = 99500, - [SMALL_STATE(2333)] = 99523, - [SMALL_STATE(2334)] = 99546, - [SMALL_STATE(2335)] = 99565, - [SMALL_STATE(2336)] = 99584, - [SMALL_STATE(2337)] = 99607, - [SMALL_STATE(2338)] = 99630, - [SMALL_STATE(2339)] = 99649, - [SMALL_STATE(2340)] = 99672, - [SMALL_STATE(2341)] = 99691, - [SMALL_STATE(2342)] = 99714, - [SMALL_STATE(2343)] = 99737, - [SMALL_STATE(2344)] = 99760, - [SMALL_STATE(2345)] = 99783, - [SMALL_STATE(2346)] = 99804, - [SMALL_STATE(2347)] = 99823, - [SMALL_STATE(2348)] = 99842, - [SMALL_STATE(2349)] = 99861, - [SMALL_STATE(2350)] = 99880, - [SMALL_STATE(2351)] = 99899, - [SMALL_STATE(2352)] = 99922, - [SMALL_STATE(2353)] = 99943, - [SMALL_STATE(2354)] = 99962, - [SMALL_STATE(2355)] = 99985, - [SMALL_STATE(2356)] = 100004, - [SMALL_STATE(2357)] = 100027, - [SMALL_STATE(2358)] = 100046, - [SMALL_STATE(2359)] = 100065, - [SMALL_STATE(2360)] = 100084, - [SMALL_STATE(2361)] = 100103, - [SMALL_STATE(2362)] = 100122, - [SMALL_STATE(2363)] = 100145, - [SMALL_STATE(2364)] = 100168, - [SMALL_STATE(2365)] = 100187, - [SMALL_STATE(2366)] = 100206, - [SMALL_STATE(2367)] = 100225, - [SMALL_STATE(2368)] = 100244, - [SMALL_STATE(2369)] = 100263, - [SMALL_STATE(2370)] = 100286, - [SMALL_STATE(2371)] = 100309, - [SMALL_STATE(2372)] = 100332, - [SMALL_STATE(2373)] = 100351, - [SMALL_STATE(2374)] = 100374, - [SMALL_STATE(2375)] = 100397, - [SMALL_STATE(2376)] = 100420, - [SMALL_STATE(2377)] = 100439, - [SMALL_STATE(2378)] = 100462, - [SMALL_STATE(2379)] = 100481, - [SMALL_STATE(2380)] = 100504, - [SMALL_STATE(2381)] = 100527, - [SMALL_STATE(2382)] = 100546, - [SMALL_STATE(2383)] = 100569, - [SMALL_STATE(2384)] = 100592, - [SMALL_STATE(2385)] = 100615, - [SMALL_STATE(2386)] = 100638, - [SMALL_STATE(2387)] = 100661, - [SMALL_STATE(2388)] = 100680, - [SMALL_STATE(2389)] = 100703, - [SMALL_STATE(2390)] = 100722, - [SMALL_STATE(2391)] = 100745, - [SMALL_STATE(2392)] = 100768, - [SMALL_STATE(2393)] = 100791, - [SMALL_STATE(2394)] = 100814, - [SMALL_STATE(2395)] = 100837, - [SMALL_STATE(2396)] = 100860, - [SMALL_STATE(2397)] = 100883, - [SMALL_STATE(2398)] = 100902, - [SMALL_STATE(2399)] = 100925, - [SMALL_STATE(2400)] = 100944, - [SMALL_STATE(2401)] = 100967, - [SMALL_STATE(2402)] = 100986, - [SMALL_STATE(2403)] = 101009, - [SMALL_STATE(2404)] = 101028, - [SMALL_STATE(2405)] = 101047, - [SMALL_STATE(2406)] = 101066, - [SMALL_STATE(2407)] = 101089, - [SMALL_STATE(2408)] = 101112, - [SMALL_STATE(2409)] = 101135, - [SMALL_STATE(2410)] = 101158, - [SMALL_STATE(2411)] = 101177, - [SMALL_STATE(2412)] = 101200, - [SMALL_STATE(2413)] = 101223, - [SMALL_STATE(2414)] = 101242, - [SMALL_STATE(2415)] = 101261, - [SMALL_STATE(2416)] = 101284, - [SMALL_STATE(2417)] = 101307, - [SMALL_STATE(2418)] = 101326, - [SMALL_STATE(2419)] = 101349, - [SMALL_STATE(2420)] = 101372, - [SMALL_STATE(2421)] = 101395, - [SMALL_STATE(2422)] = 101418, - [SMALL_STATE(2423)] = 101441, - [SMALL_STATE(2424)] = 101464, - [SMALL_STATE(2425)] = 101487, - [SMALL_STATE(2426)] = 101510, - [SMALL_STATE(2427)] = 101533, - [SMALL_STATE(2428)] = 101556, - [SMALL_STATE(2429)] = 101579, - [SMALL_STATE(2430)] = 101602, - [SMALL_STATE(2431)] = 101625, - [SMALL_STATE(2432)] = 101644, - [SMALL_STATE(2433)] = 101663, - [SMALL_STATE(2434)] = 101682, - [SMALL_STATE(2435)] = 101705, - [SMALL_STATE(2436)] = 101728, - [SMALL_STATE(2437)] = 101747, - [SMALL_STATE(2438)] = 101770, - [SMALL_STATE(2439)] = 101793, - [SMALL_STATE(2440)] = 101812, - [SMALL_STATE(2441)] = 101831, - [SMALL_STATE(2442)] = 101854, - [SMALL_STATE(2443)] = 101877, - [SMALL_STATE(2444)] = 101900, - [SMALL_STATE(2445)] = 101923, - [SMALL_STATE(2446)] = 101942, - [SMALL_STATE(2447)] = 101961, - [SMALL_STATE(2448)] = 101984, - [SMALL_STATE(2449)] = 102007, - [SMALL_STATE(2450)] = 102026, - [SMALL_STATE(2451)] = 102049, - [SMALL_STATE(2452)] = 102068, - [SMALL_STATE(2453)] = 102091, - [SMALL_STATE(2454)] = 102110, - [SMALL_STATE(2455)] = 102133, - [SMALL_STATE(2456)] = 102156, - [SMALL_STATE(2457)] = 102179, - [SMALL_STATE(2458)] = 102202, - [SMALL_STATE(2459)] = 102221, - [SMALL_STATE(2460)] = 102244, - [SMALL_STATE(2461)] = 102263, - [SMALL_STATE(2462)] = 102282, - [SMALL_STATE(2463)] = 102301, - [SMALL_STATE(2464)] = 102320, - [SMALL_STATE(2465)] = 102339, - [SMALL_STATE(2466)] = 102362, - [SMALL_STATE(2467)] = 102385, - [SMALL_STATE(2468)] = 102408, - [SMALL_STATE(2469)] = 102431, - [SMALL_STATE(2470)] = 102454, - [SMALL_STATE(2471)] = 102473, - [SMALL_STATE(2472)] = 102496, - [SMALL_STATE(2473)] = 102519, - [SMALL_STATE(2474)] = 102538, - [SMALL_STATE(2475)] = 102561, - [SMALL_STATE(2476)] = 102580, - [SMALL_STATE(2477)] = 102599, - [SMALL_STATE(2478)] = 102618, - [SMALL_STATE(2479)] = 102637, - [SMALL_STATE(2480)] = 102656, - [SMALL_STATE(2481)] = 102679, - [SMALL_STATE(2482)] = 102702, - [SMALL_STATE(2483)] = 102725, - [SMALL_STATE(2484)] = 102748, - [SMALL_STATE(2485)] = 102771, - [SMALL_STATE(2486)] = 102790, - [SMALL_STATE(2487)] = 102809, - [SMALL_STATE(2488)] = 102828, - [SMALL_STATE(2489)] = 102851, - [SMALL_STATE(2490)] = 102874, - [SMALL_STATE(2491)] = 102897, - [SMALL_STATE(2492)] = 102920, - [SMALL_STATE(2493)] = 102943, - [SMALL_STATE(2494)] = 102962, - [SMALL_STATE(2495)] = 102985, - [SMALL_STATE(2496)] = 103008, - [SMALL_STATE(2497)] = 103027, - [SMALL_STATE(2498)] = 103050, - [SMALL_STATE(2499)] = 103069, - [SMALL_STATE(2500)] = 103088, - [SMALL_STATE(2501)] = 103107, - [SMALL_STATE(2502)] = 103126, - [SMALL_STATE(2503)] = 103149, - [SMALL_STATE(2504)] = 103172, - [SMALL_STATE(2505)] = 103195, - [SMALL_STATE(2506)] = 103218, - [SMALL_STATE(2507)] = 103241, - [SMALL_STATE(2508)] = 103264, - [SMALL_STATE(2509)] = 103287, - [SMALL_STATE(2510)] = 103310, - [SMALL_STATE(2511)] = 103333, - [SMALL_STATE(2512)] = 103356, - [SMALL_STATE(2513)] = 103375, - [SMALL_STATE(2514)] = 103394, - [SMALL_STATE(2515)] = 103413, - [SMALL_STATE(2516)] = 103436, - [SMALL_STATE(2517)] = 103459, - [SMALL_STATE(2518)] = 103482, - [SMALL_STATE(2519)] = 103501, - [SMALL_STATE(2520)] = 103524, - [SMALL_STATE(2521)] = 103547, - [SMALL_STATE(2522)] = 103570, - [SMALL_STATE(2523)] = 103593, - [SMALL_STATE(2524)] = 103616, - [SMALL_STATE(2525)] = 103639, - [SMALL_STATE(2526)] = 103662, - [SMALL_STATE(2527)] = 103685, - [SMALL_STATE(2528)] = 103708, - [SMALL_STATE(2529)] = 103731, - [SMALL_STATE(2530)] = 103750, - [SMALL_STATE(2531)] = 103773, - [SMALL_STATE(2532)] = 103796, - [SMALL_STATE(2533)] = 103819, - [SMALL_STATE(2534)] = 103838, - [SMALL_STATE(2535)] = 103857, - [SMALL_STATE(2536)] = 103878, - [SMALL_STATE(2537)] = 103897, - [SMALL_STATE(2538)] = 103920, - [SMALL_STATE(2539)] = 103941, - [SMALL_STATE(2540)] = 103960, - [SMALL_STATE(2541)] = 103983, - [SMALL_STATE(2542)] = 104006, - [SMALL_STATE(2543)] = 104029, - [SMALL_STATE(2544)] = 104048, - [SMALL_STATE(2545)] = 104071, - [SMALL_STATE(2546)] = 104094, - [SMALL_STATE(2547)] = 104117, - [SMALL_STATE(2548)] = 104140, - [SMALL_STATE(2549)] = 104163, - [SMALL_STATE(2550)] = 104186, - [SMALL_STATE(2551)] = 104209, - [SMALL_STATE(2552)] = 104232, - [SMALL_STATE(2553)] = 104255, - [SMALL_STATE(2554)] = 104278, - [SMALL_STATE(2555)] = 104301, - [SMALL_STATE(2556)] = 104324, - [SMALL_STATE(2557)] = 104347, - [SMALL_STATE(2558)] = 104370, - [SMALL_STATE(2559)] = 104390, - [SMALL_STATE(2560)] = 104410, - [SMALL_STATE(2561)] = 104430, - [SMALL_STATE(2562)] = 104450, - [SMALL_STATE(2563)] = 104470, - [SMALL_STATE(2564)] = 104490, - [SMALL_STATE(2565)] = 104510, - [SMALL_STATE(2566)] = 104530, - [SMALL_STATE(2567)] = 104550, - [SMALL_STATE(2568)] = 104570, - [SMALL_STATE(2569)] = 104590, - [SMALL_STATE(2570)] = 104610, - [SMALL_STATE(2571)] = 104630, - [SMALL_STATE(2572)] = 104650, - [SMALL_STATE(2573)] = 104668, - [SMALL_STATE(2574)] = 104688, - [SMALL_STATE(2575)] = 104708, - [SMALL_STATE(2576)] = 104728, - [SMALL_STATE(2577)] = 104748, - [SMALL_STATE(2578)] = 104768, - [SMALL_STATE(2579)] = 104788, - [SMALL_STATE(2580)] = 104808, - [SMALL_STATE(2581)] = 104828, - [SMALL_STATE(2582)] = 104848, - [SMALL_STATE(2583)] = 104868, - [SMALL_STATE(2584)] = 104888, - [SMALL_STATE(2585)] = 104908, - [SMALL_STATE(2586)] = 104928, - [SMALL_STATE(2587)] = 104948, - [SMALL_STATE(2588)] = 104968, - [SMALL_STATE(2589)] = 104988, - [SMALL_STATE(2590)] = 105008, - [SMALL_STATE(2591)] = 105028, - [SMALL_STATE(2592)] = 105048, - [SMALL_STATE(2593)] = 105068, - [SMALL_STATE(2594)] = 105088, - [SMALL_STATE(2595)] = 105108, - [SMALL_STATE(2596)] = 105128, - [SMALL_STATE(2597)] = 105148, - [SMALL_STATE(2598)] = 105168, - [SMALL_STATE(2599)] = 105188, - [SMALL_STATE(2600)] = 105208, - [SMALL_STATE(2601)] = 105228, - [SMALL_STATE(2602)] = 105248, - [SMALL_STATE(2603)] = 105268, - [SMALL_STATE(2604)] = 105288, - [SMALL_STATE(2605)] = 105306, - [SMALL_STATE(2606)] = 105326, - [SMALL_STATE(2607)] = 105346, - [SMALL_STATE(2608)] = 105366, - [SMALL_STATE(2609)] = 105386, - [SMALL_STATE(2610)] = 105406, - [SMALL_STATE(2611)] = 105426, - [SMALL_STATE(2612)] = 105446, - [SMALL_STATE(2613)] = 105466, - [SMALL_STATE(2614)] = 105486, - [SMALL_STATE(2615)] = 105506, - [SMALL_STATE(2616)] = 105526, - [SMALL_STATE(2617)] = 105546, - [SMALL_STATE(2618)] = 105566, - [SMALL_STATE(2619)] = 105586, - [SMALL_STATE(2620)] = 105606, - [SMALL_STATE(2621)] = 105626, - [SMALL_STATE(2622)] = 105646, - [SMALL_STATE(2623)] = 105666, - [SMALL_STATE(2624)] = 105686, - [SMALL_STATE(2625)] = 105706, - [SMALL_STATE(2626)] = 105726, - [SMALL_STATE(2627)] = 105746, - [SMALL_STATE(2628)] = 105766, - [SMALL_STATE(2629)] = 105786, - [SMALL_STATE(2630)] = 105806, - [SMALL_STATE(2631)] = 105826, - [SMALL_STATE(2632)] = 105846, - [SMALL_STATE(2633)] = 105866, - [SMALL_STATE(2634)] = 105886, - [SMALL_STATE(2635)] = 105906, - [SMALL_STATE(2636)] = 105926, - [SMALL_STATE(2637)] = 105946, - [SMALL_STATE(2638)] = 105966, - [SMALL_STATE(2639)] = 105986, - [SMALL_STATE(2640)] = 106006, - [SMALL_STATE(2641)] = 106024, - [SMALL_STATE(2642)] = 106044, - [SMALL_STATE(2643)] = 106064, - [SMALL_STATE(2644)] = 106084, - [SMALL_STATE(2645)] = 106104, - [SMALL_STATE(2646)] = 106124, - [SMALL_STATE(2647)] = 106144, - [SMALL_STATE(2648)] = 106164, - [SMALL_STATE(2649)] = 106184, - [SMALL_STATE(2650)] = 106204, - [SMALL_STATE(2651)] = 106224, - [SMALL_STATE(2652)] = 106244, - [SMALL_STATE(2653)] = 106264, - [SMALL_STATE(2654)] = 106284, - [SMALL_STATE(2655)] = 106304, - [SMALL_STATE(2656)] = 106324, - [SMALL_STATE(2657)] = 106344, - [SMALL_STATE(2658)] = 106364, - [SMALL_STATE(2659)] = 106384, - [SMALL_STATE(2660)] = 106404, - [SMALL_STATE(2661)] = 106424, - [SMALL_STATE(2662)] = 106444, - [SMALL_STATE(2663)] = 106464, - [SMALL_STATE(2664)] = 106482, - [SMALL_STATE(2665)] = 106502, - [SMALL_STATE(2666)] = 106522, - [SMALL_STATE(2667)] = 106542, - [SMALL_STATE(2668)] = 106562, - [SMALL_STATE(2669)] = 106582, - [SMALL_STATE(2670)] = 106602, - [SMALL_STATE(2671)] = 106622, - [SMALL_STATE(2672)] = 106640, - [SMALL_STATE(2673)] = 106660, - [SMALL_STATE(2674)] = 106680, - [SMALL_STATE(2675)] = 106700, - [SMALL_STATE(2676)] = 106720, - [SMALL_STATE(2677)] = 106740, - [SMALL_STATE(2678)] = 106760, - [SMALL_STATE(2679)] = 106780, - [SMALL_STATE(2680)] = 106800, - [SMALL_STATE(2681)] = 106820, - [SMALL_STATE(2682)] = 106840, - [SMALL_STATE(2683)] = 106860, - [SMALL_STATE(2684)] = 106880, - [SMALL_STATE(2685)] = 106900, - [SMALL_STATE(2686)] = 106920, - [SMALL_STATE(2687)] = 106940, - [SMALL_STATE(2688)] = 106960, - [SMALL_STATE(2689)] = 106980, - [SMALL_STATE(2690)] = 107000, - [SMALL_STATE(2691)] = 107020, - [SMALL_STATE(2692)] = 107040, - [SMALL_STATE(2693)] = 107060, - [SMALL_STATE(2694)] = 107080, - [SMALL_STATE(2695)] = 107100, - [SMALL_STATE(2696)] = 107120, - [SMALL_STATE(2697)] = 107140, - [SMALL_STATE(2698)] = 107158, - [SMALL_STATE(2699)] = 107178, - [SMALL_STATE(2700)] = 107198, - [SMALL_STATE(2701)] = 107218, - [SMALL_STATE(2702)] = 107238, - [SMALL_STATE(2703)] = 107258, - [SMALL_STATE(2704)] = 107278, - [SMALL_STATE(2705)] = 107298, - [SMALL_STATE(2706)] = 107318, - [SMALL_STATE(2707)] = 107338, - [SMALL_STATE(2708)] = 107358, - [SMALL_STATE(2709)] = 107378, - [SMALL_STATE(2710)] = 107398, - [SMALL_STATE(2711)] = 107418, - [SMALL_STATE(2712)] = 107438, - [SMALL_STATE(2713)] = 107458, - [SMALL_STATE(2714)] = 107478, - [SMALL_STATE(2715)] = 107498, - [SMALL_STATE(2716)] = 107518, - [SMALL_STATE(2717)] = 107538, - [SMALL_STATE(2718)] = 107558, - [SMALL_STATE(2719)] = 107578, - [SMALL_STATE(2720)] = 107598, - [SMALL_STATE(2721)] = 107618, - [SMALL_STATE(2722)] = 107638, - [SMALL_STATE(2723)] = 107658, - [SMALL_STATE(2724)] = 107678, - [SMALL_STATE(2725)] = 107698, - [SMALL_STATE(2726)] = 107718, - [SMALL_STATE(2727)] = 107738, - [SMALL_STATE(2728)] = 107758, - [SMALL_STATE(2729)] = 107778, - [SMALL_STATE(2730)] = 107798, - [SMALL_STATE(2731)] = 107818, - [SMALL_STATE(2732)] = 107838, - [SMALL_STATE(2733)] = 107858, - [SMALL_STATE(2734)] = 107878, - [SMALL_STATE(2735)] = 107898, - [SMALL_STATE(2736)] = 107918, - [SMALL_STATE(2737)] = 107938, - [SMALL_STATE(2738)] = 107958, - [SMALL_STATE(2739)] = 107978, - [SMALL_STATE(2740)] = 107998, - [SMALL_STATE(2741)] = 108018, - [SMALL_STATE(2742)] = 108038, - [SMALL_STATE(2743)] = 108058, - [SMALL_STATE(2744)] = 108078, - [SMALL_STATE(2745)] = 108098, - [SMALL_STATE(2746)] = 108118, - [SMALL_STATE(2747)] = 108138, - [SMALL_STATE(2748)] = 108158, - [SMALL_STATE(2749)] = 108178, - [SMALL_STATE(2750)] = 108198, - [SMALL_STATE(2751)] = 108218, - [SMALL_STATE(2752)] = 108238, - [SMALL_STATE(2753)] = 108258, - [SMALL_STATE(2754)] = 108278, - [SMALL_STATE(2755)] = 108298, - [SMALL_STATE(2756)] = 108318, - [SMALL_STATE(2757)] = 108338, - [SMALL_STATE(2758)] = 108358, - [SMALL_STATE(2759)] = 108378, - [SMALL_STATE(2760)] = 108398, - [SMALL_STATE(2761)] = 108418, - [SMALL_STATE(2762)] = 108438, - [SMALL_STATE(2763)] = 108458, - [SMALL_STATE(2764)] = 108478, - [SMALL_STATE(2765)] = 108498, - [SMALL_STATE(2766)] = 108518, - [SMALL_STATE(2767)] = 108538, - [SMALL_STATE(2768)] = 108558, - [SMALL_STATE(2769)] = 108578, - [SMALL_STATE(2770)] = 108598, - [SMALL_STATE(2771)] = 108618, - [SMALL_STATE(2772)] = 108638, - [SMALL_STATE(2773)] = 108658, - [SMALL_STATE(2774)] = 108676, - [SMALL_STATE(2775)] = 108696, - [SMALL_STATE(2776)] = 108716, - [SMALL_STATE(2777)] = 108736, - [SMALL_STATE(2778)] = 108756, - [SMALL_STATE(2779)] = 108776, - [SMALL_STATE(2780)] = 108796, - [SMALL_STATE(2781)] = 108816, - [SMALL_STATE(2782)] = 108836, - [SMALL_STATE(2783)] = 108856, - [SMALL_STATE(2784)] = 108876, - [SMALL_STATE(2785)] = 108896, - [SMALL_STATE(2786)] = 108916, - [SMALL_STATE(2787)] = 108936, - [SMALL_STATE(2788)] = 108956, - [SMALL_STATE(2789)] = 108976, - [SMALL_STATE(2790)] = 108996, - [SMALL_STATE(2791)] = 109016, - [SMALL_STATE(2792)] = 109036, - [SMALL_STATE(2793)] = 109054, - [SMALL_STATE(2794)] = 109074, - [SMALL_STATE(2795)] = 109094, - [SMALL_STATE(2796)] = 109114, - [SMALL_STATE(2797)] = 109134, - [SMALL_STATE(2798)] = 109154, - [SMALL_STATE(2799)] = 109174, - [SMALL_STATE(2800)] = 109194, - [SMALL_STATE(2801)] = 109214, - [SMALL_STATE(2802)] = 109232, - [SMALL_STATE(2803)] = 109252, - [SMALL_STATE(2804)] = 109272, - [SMALL_STATE(2805)] = 109290, - [SMALL_STATE(2806)] = 109310, - [SMALL_STATE(2807)] = 109330, - [SMALL_STATE(2808)] = 109350, - [SMALL_STATE(2809)] = 109370, - [SMALL_STATE(2810)] = 109390, - [SMALL_STATE(2811)] = 109410, - [SMALL_STATE(2812)] = 109430, - [SMALL_STATE(2813)] = 109450, - [SMALL_STATE(2814)] = 109470, - [SMALL_STATE(2815)] = 109490, - [SMALL_STATE(2816)] = 109510, - [SMALL_STATE(2817)] = 109530, - [SMALL_STATE(2818)] = 109550, - [SMALL_STATE(2819)] = 109570, - [SMALL_STATE(2820)] = 109590, - [SMALL_STATE(2821)] = 109610, - [SMALL_STATE(2822)] = 109630, - [SMALL_STATE(2823)] = 109650, - [SMALL_STATE(2824)] = 109670, - [SMALL_STATE(2825)] = 109690, - [SMALL_STATE(2826)] = 109710, - [SMALL_STATE(2827)] = 109730, - [SMALL_STATE(2828)] = 109750, - [SMALL_STATE(2829)] = 109768, - [SMALL_STATE(2830)] = 109788, - [SMALL_STATE(2831)] = 109808, - [SMALL_STATE(2832)] = 109826, - [SMALL_STATE(2833)] = 109846, - [SMALL_STATE(2834)] = 109866, - [SMALL_STATE(2835)] = 109886, - [SMALL_STATE(2836)] = 109906, - [SMALL_STATE(2837)] = 109926, - [SMALL_STATE(2838)] = 109946, - [SMALL_STATE(2839)] = 109966, - [SMALL_STATE(2840)] = 109986, - [SMALL_STATE(2841)] = 110006, - [SMALL_STATE(2842)] = 110026, - [SMALL_STATE(2843)] = 110046, - [SMALL_STATE(2844)] = 110066, - [SMALL_STATE(2845)] = 110084, - [SMALL_STATE(2846)] = 110104, - [SMALL_STATE(2847)] = 110124, - [SMALL_STATE(2848)] = 110144, - [SMALL_STATE(2849)] = 110164, - [SMALL_STATE(2850)] = 110184, - [SMALL_STATE(2851)] = 110204, - [SMALL_STATE(2852)] = 110224, - [SMALL_STATE(2853)] = 110244, - [SMALL_STATE(2854)] = 110264, - [SMALL_STATE(2855)] = 110284, - [SMALL_STATE(2856)] = 110304, - [SMALL_STATE(2857)] = 110324, - [SMALL_STATE(2858)] = 110344, - [SMALL_STATE(2859)] = 110364, - [SMALL_STATE(2860)] = 110382, - [SMALL_STATE(2861)] = 110402, - [SMALL_STATE(2862)] = 110422, - [SMALL_STATE(2863)] = 110442, - [SMALL_STATE(2864)] = 110460, - [SMALL_STATE(2865)] = 110480, - [SMALL_STATE(2866)] = 110500, - [SMALL_STATE(2867)] = 110518, - [SMALL_STATE(2868)] = 110538, - [SMALL_STATE(2869)] = 110558, - [SMALL_STATE(2870)] = 110578, - [SMALL_STATE(2871)] = 110598, - [SMALL_STATE(2872)] = 110618, - [SMALL_STATE(2873)] = 110638, - [SMALL_STATE(2874)] = 110658, - [SMALL_STATE(2875)] = 110678, - [SMALL_STATE(2876)] = 110698, - [SMALL_STATE(2877)] = 110718, - [SMALL_STATE(2878)] = 110738, - [SMALL_STATE(2879)] = 110756, - [SMALL_STATE(2880)] = 110776, - [SMALL_STATE(2881)] = 110796, - [SMALL_STATE(2882)] = 110816, - [SMALL_STATE(2883)] = 110836, - [SMALL_STATE(2884)] = 110856, - [SMALL_STATE(2885)] = 110876, - [SMALL_STATE(2886)] = 110896, - [SMALL_STATE(2887)] = 110916, - [SMALL_STATE(2888)] = 110936, - [SMALL_STATE(2889)] = 110956, - [SMALL_STATE(2890)] = 110976, - [SMALL_STATE(2891)] = 110996, - [SMALL_STATE(2892)] = 111016, - [SMALL_STATE(2893)] = 111036, - [SMALL_STATE(2894)] = 111056, - [SMALL_STATE(2895)] = 111076, - [SMALL_STATE(2896)] = 111096, - [SMALL_STATE(2897)] = 111116, - [SMALL_STATE(2898)] = 111136, - [SMALL_STATE(2899)] = 111156, - [SMALL_STATE(2900)] = 111176, - [SMALL_STATE(2901)] = 111196, - [SMALL_STATE(2902)] = 111216, - [SMALL_STATE(2903)] = 111234, - [SMALL_STATE(2904)] = 111254, - [SMALL_STATE(2905)] = 111274, - [SMALL_STATE(2906)] = 111292, - [SMALL_STATE(2907)] = 111310, - [SMALL_STATE(2908)] = 111330, - [SMALL_STATE(2909)] = 111348, - [SMALL_STATE(2910)] = 111368, - [SMALL_STATE(2911)] = 111386, - [SMALL_STATE(2912)] = 111404, - [SMALL_STATE(2913)] = 111424, - [SMALL_STATE(2914)] = 111444, - [SMALL_STATE(2915)] = 111464, - [SMALL_STATE(2916)] = 111484, - [SMALL_STATE(2917)] = 111502, - [SMALL_STATE(2918)] = 111522, - [SMALL_STATE(2919)] = 111542, - [SMALL_STATE(2920)] = 111562, - [SMALL_STATE(2921)] = 111582, - [SMALL_STATE(2922)] = 111602, - [SMALL_STATE(2923)] = 111622, - [SMALL_STATE(2924)] = 111642, - [SMALL_STATE(2925)] = 111662, - [SMALL_STATE(2926)] = 111682, - [SMALL_STATE(2927)] = 111702, - [SMALL_STATE(2928)] = 111722, - [SMALL_STATE(2929)] = 111742, - [SMALL_STATE(2930)] = 111760, - [SMALL_STATE(2931)] = 111780, - [SMALL_STATE(2932)] = 111798, - [SMALL_STATE(2933)] = 111818, - [SMALL_STATE(2934)] = 111836, - [SMALL_STATE(2935)] = 111856, - [SMALL_STATE(2936)] = 111874, - [SMALL_STATE(2937)] = 111892, - [SMALL_STATE(2938)] = 111912, - [SMALL_STATE(2939)] = 111932, - [SMALL_STATE(2940)] = 111952, - [SMALL_STATE(2941)] = 111970, - [SMALL_STATE(2942)] = 111990, - [SMALL_STATE(2943)] = 112010, - [SMALL_STATE(2944)] = 112030, - [SMALL_STATE(2945)] = 112050, - [SMALL_STATE(2946)] = 112070, - [SMALL_STATE(2947)] = 112090, - [SMALL_STATE(2948)] = 112108, - [SMALL_STATE(2949)] = 112128, - [SMALL_STATE(2950)] = 112148, - [SMALL_STATE(2951)] = 112166, - [SMALL_STATE(2952)] = 112184, - [SMALL_STATE(2953)] = 112204, - [SMALL_STATE(2954)] = 112224, - [SMALL_STATE(2955)] = 112242, - [SMALL_STATE(2956)] = 112262, - [SMALL_STATE(2957)] = 112282, - [SMALL_STATE(2958)] = 112300, - [SMALL_STATE(2959)] = 112320, - [SMALL_STATE(2960)] = 112340, - [SMALL_STATE(2961)] = 112360, - [SMALL_STATE(2962)] = 112380, - [SMALL_STATE(2963)] = 112398, - [SMALL_STATE(2964)] = 112418, - [SMALL_STATE(2965)] = 112438, - [SMALL_STATE(2966)] = 112458, - [SMALL_STATE(2967)] = 112476, - [SMALL_STATE(2968)] = 112496, - [SMALL_STATE(2969)] = 112514, - [SMALL_STATE(2970)] = 112531, - [SMALL_STATE(2971)] = 112548, - [SMALL_STATE(2972)] = 112565, - [SMALL_STATE(2973)] = 112582, - [SMALL_STATE(2974)] = 112599, - [SMALL_STATE(2975)] = 112616, - [SMALL_STATE(2976)] = 112633, - [SMALL_STATE(2977)] = 112650, - [SMALL_STATE(2978)] = 112667, - [SMALL_STATE(2979)] = 112684, - [SMALL_STATE(2980)] = 112701, - [SMALL_STATE(2981)] = 112718, - [SMALL_STATE(2982)] = 112735, - [SMALL_STATE(2983)] = 112752, - [SMALL_STATE(2984)] = 112769, - [SMALL_STATE(2985)] = 112786, - [SMALL_STATE(2986)] = 112803, - [SMALL_STATE(2987)] = 112820, - [SMALL_STATE(2988)] = 112837, - [SMALL_STATE(2989)] = 112854, - [SMALL_STATE(2990)] = 112871, - [SMALL_STATE(2991)] = 112888, - [SMALL_STATE(2992)] = 112905, - [SMALL_STATE(2993)] = 112922, - [SMALL_STATE(2994)] = 112939, - [SMALL_STATE(2995)] = 112956, - [SMALL_STATE(2996)] = 112973, - [SMALL_STATE(2997)] = 112990, - [SMALL_STATE(2998)] = 113007, - [SMALL_STATE(2999)] = 113024, - [SMALL_STATE(3000)] = 113041, - [SMALL_STATE(3001)] = 113058, - [SMALL_STATE(3002)] = 113075, - [SMALL_STATE(3003)] = 113092, - [SMALL_STATE(3004)] = 113109, - [SMALL_STATE(3005)] = 113126, - [SMALL_STATE(3006)] = 113143, - [SMALL_STATE(3007)] = 113160, - [SMALL_STATE(3008)] = 113177, - [SMALL_STATE(3009)] = 113194, - [SMALL_STATE(3010)] = 113211, - [SMALL_STATE(3011)] = 113228, - [SMALL_STATE(3012)] = 113245, - [SMALL_STATE(3013)] = 113262, - [SMALL_STATE(3014)] = 113279, - [SMALL_STATE(3015)] = 113296, - [SMALL_STATE(3016)] = 113313, - [SMALL_STATE(3017)] = 113330, - [SMALL_STATE(3018)] = 113347, - [SMALL_STATE(3019)] = 113364, - [SMALL_STATE(3020)] = 113381, - [SMALL_STATE(3021)] = 113398, - [SMALL_STATE(3022)] = 113415, - [SMALL_STATE(3023)] = 113432, - [SMALL_STATE(3024)] = 113449, - [SMALL_STATE(3025)] = 113466, - [SMALL_STATE(3026)] = 113483, - [SMALL_STATE(3027)] = 113500, - [SMALL_STATE(3028)] = 113517, - [SMALL_STATE(3029)] = 113534, - [SMALL_STATE(3030)] = 113551, - [SMALL_STATE(3031)] = 113568, - [SMALL_STATE(3032)] = 113585, - [SMALL_STATE(3033)] = 113602, - [SMALL_STATE(3034)] = 113619, - [SMALL_STATE(3035)] = 113636, - [SMALL_STATE(3036)] = 113653, - [SMALL_STATE(3037)] = 113670, - [SMALL_STATE(3038)] = 113687, - [SMALL_STATE(3039)] = 113704, - [SMALL_STATE(3040)] = 113721, - [SMALL_STATE(3041)] = 113738, - [SMALL_STATE(3042)] = 113755, - [SMALL_STATE(3043)] = 113772, - [SMALL_STATE(3044)] = 113789, - [SMALL_STATE(3045)] = 113806, - [SMALL_STATE(3046)] = 113823, - [SMALL_STATE(3047)] = 113840, - [SMALL_STATE(3048)] = 113857, - [SMALL_STATE(3049)] = 113874, - [SMALL_STATE(3050)] = 113891, - [SMALL_STATE(3051)] = 113908, - [SMALL_STATE(3052)] = 113925, - [SMALL_STATE(3053)] = 113942, - [SMALL_STATE(3054)] = 113959, - [SMALL_STATE(3055)] = 113976, - [SMALL_STATE(3056)] = 113993, - [SMALL_STATE(3057)] = 114010, - [SMALL_STATE(3058)] = 114027, - [SMALL_STATE(3059)] = 114044, - [SMALL_STATE(3060)] = 114061, - [SMALL_STATE(3061)] = 114078, - [SMALL_STATE(3062)] = 114095, - [SMALL_STATE(3063)] = 114112, - [SMALL_STATE(3064)] = 114129, - [SMALL_STATE(3065)] = 114146, - [SMALL_STATE(3066)] = 114163, - [SMALL_STATE(3067)] = 114180, - [SMALL_STATE(3068)] = 114197, - [SMALL_STATE(3069)] = 114214, - [SMALL_STATE(3070)] = 114231, - [SMALL_STATE(3071)] = 114248, - [SMALL_STATE(3072)] = 114265, - [SMALL_STATE(3073)] = 114282, - [SMALL_STATE(3074)] = 114299, - [SMALL_STATE(3075)] = 114316, - [SMALL_STATE(3076)] = 114333, - [SMALL_STATE(3077)] = 114350, - [SMALL_STATE(3078)] = 114367, - [SMALL_STATE(3079)] = 114384, - [SMALL_STATE(3080)] = 114401, - [SMALL_STATE(3081)] = 114418, - [SMALL_STATE(3082)] = 114435, - [SMALL_STATE(3083)] = 114452, - [SMALL_STATE(3084)] = 114469, - [SMALL_STATE(3085)] = 114486, - [SMALL_STATE(3086)] = 114503, - [SMALL_STATE(3087)] = 114520, - [SMALL_STATE(3088)] = 114537, - [SMALL_STATE(3089)] = 114554, - [SMALL_STATE(3090)] = 114571, - [SMALL_STATE(3091)] = 114588, - [SMALL_STATE(3092)] = 114605, - [SMALL_STATE(3093)] = 114622, - [SMALL_STATE(3094)] = 114639, - [SMALL_STATE(3095)] = 114656, - [SMALL_STATE(3096)] = 114673, - [SMALL_STATE(3097)] = 114690, - [SMALL_STATE(3098)] = 114707, - [SMALL_STATE(3099)] = 114724, - [SMALL_STATE(3100)] = 114741, - [SMALL_STATE(3101)] = 114758, - [SMALL_STATE(3102)] = 114775, - [SMALL_STATE(3103)] = 114792, - [SMALL_STATE(3104)] = 114809, - [SMALL_STATE(3105)] = 114826, - [SMALL_STATE(3106)] = 114843, - [SMALL_STATE(3107)] = 114860, - [SMALL_STATE(3108)] = 114877, - [SMALL_STATE(3109)] = 114894, - [SMALL_STATE(3110)] = 114911, - [SMALL_STATE(3111)] = 114928, - [SMALL_STATE(3112)] = 114945, - [SMALL_STATE(3113)] = 114962, - [SMALL_STATE(3114)] = 114979, - [SMALL_STATE(3115)] = 114996, - [SMALL_STATE(3116)] = 115013, - [SMALL_STATE(3117)] = 115030, - [SMALL_STATE(3118)] = 115047, - [SMALL_STATE(3119)] = 115064, - [SMALL_STATE(3120)] = 115081, - [SMALL_STATE(3121)] = 115098, - [SMALL_STATE(3122)] = 115115, - [SMALL_STATE(3123)] = 115132, - [SMALL_STATE(3124)] = 115149, - [SMALL_STATE(3125)] = 115166, - [SMALL_STATE(3126)] = 115183, - [SMALL_STATE(3127)] = 115200, - [SMALL_STATE(3128)] = 115217, - [SMALL_STATE(3129)] = 115234, - [SMALL_STATE(3130)] = 115251, - [SMALL_STATE(3131)] = 115268, - [SMALL_STATE(3132)] = 115285, - [SMALL_STATE(3133)] = 115302, - [SMALL_STATE(3134)] = 115319, - [SMALL_STATE(3135)] = 115336, - [SMALL_STATE(3136)] = 115353, - [SMALL_STATE(3137)] = 115370, - [SMALL_STATE(3138)] = 115387, - [SMALL_STATE(3139)] = 115404, - [SMALL_STATE(3140)] = 115421, - [SMALL_STATE(3141)] = 115438, - [SMALL_STATE(3142)] = 115455, - [SMALL_STATE(3143)] = 115472, - [SMALL_STATE(3144)] = 115489, - [SMALL_STATE(3145)] = 115506, - [SMALL_STATE(3146)] = 115523, - [SMALL_STATE(3147)] = 115540, - [SMALL_STATE(3148)] = 115557, - [SMALL_STATE(3149)] = 115574, - [SMALL_STATE(3150)] = 115591, - [SMALL_STATE(3151)] = 115608, - [SMALL_STATE(3152)] = 115625, - [SMALL_STATE(3153)] = 115642, - [SMALL_STATE(3154)] = 115659, - [SMALL_STATE(3155)] = 115676, - [SMALL_STATE(3156)] = 115693, - [SMALL_STATE(3157)] = 115710, - [SMALL_STATE(3158)] = 115727, - [SMALL_STATE(3159)] = 115744, - [SMALL_STATE(3160)] = 115761, - [SMALL_STATE(3161)] = 115778, - [SMALL_STATE(3162)] = 115795, - [SMALL_STATE(3163)] = 115812, - [SMALL_STATE(3164)] = 115829, - [SMALL_STATE(3165)] = 115846, - [SMALL_STATE(3166)] = 115863, - [SMALL_STATE(3167)] = 115880, - [SMALL_STATE(3168)] = 115897, - [SMALL_STATE(3169)] = 115914, - [SMALL_STATE(3170)] = 115931, - [SMALL_STATE(3171)] = 115948, - [SMALL_STATE(3172)] = 115965, - [SMALL_STATE(3173)] = 115982, - [SMALL_STATE(3174)] = 115999, - [SMALL_STATE(3175)] = 116016, - [SMALL_STATE(3176)] = 116033, - [SMALL_STATE(3177)] = 116050, - [SMALL_STATE(3178)] = 116067, - [SMALL_STATE(3179)] = 116084, - [SMALL_STATE(3180)] = 116101, - [SMALL_STATE(3181)] = 116118, - [SMALL_STATE(3182)] = 116135, - [SMALL_STATE(3183)] = 116152, - [SMALL_STATE(3184)] = 116169, - [SMALL_STATE(3185)] = 116186, - [SMALL_STATE(3186)] = 116203, - [SMALL_STATE(3187)] = 116220, - [SMALL_STATE(3188)] = 116237, - [SMALL_STATE(3189)] = 116254, - [SMALL_STATE(3190)] = 116271, - [SMALL_STATE(3191)] = 116288, - [SMALL_STATE(3192)] = 116305, - [SMALL_STATE(3193)] = 116322, - [SMALL_STATE(3194)] = 116339, - [SMALL_STATE(3195)] = 116356, - [SMALL_STATE(3196)] = 116373, - [SMALL_STATE(3197)] = 116390, - [SMALL_STATE(3198)] = 116407, - [SMALL_STATE(3199)] = 116424, - [SMALL_STATE(3200)] = 116441, - [SMALL_STATE(3201)] = 116458, - [SMALL_STATE(3202)] = 116475, - [SMALL_STATE(3203)] = 116492, - [SMALL_STATE(3204)] = 116509, - [SMALL_STATE(3205)] = 116526, - [SMALL_STATE(3206)] = 116543, - [SMALL_STATE(3207)] = 116560, - [SMALL_STATE(3208)] = 116577, - [SMALL_STATE(3209)] = 116594, - [SMALL_STATE(3210)] = 116611, - [SMALL_STATE(3211)] = 116628, - [SMALL_STATE(3212)] = 116645, - [SMALL_STATE(3213)] = 116662, - [SMALL_STATE(3214)] = 116679, - [SMALL_STATE(3215)] = 116696, - [SMALL_STATE(3216)] = 116713, - [SMALL_STATE(3217)] = 116730, - [SMALL_STATE(3218)] = 116747, - [SMALL_STATE(3219)] = 116764, - [SMALL_STATE(3220)] = 116781, - [SMALL_STATE(3221)] = 116798, - [SMALL_STATE(3222)] = 116815, - [SMALL_STATE(3223)] = 116832, - [SMALL_STATE(3224)] = 116849, - [SMALL_STATE(3225)] = 116866, - [SMALL_STATE(3226)] = 116883, - [SMALL_STATE(3227)] = 116900, - [SMALL_STATE(3228)] = 116917, - [SMALL_STATE(3229)] = 116934, - [SMALL_STATE(3230)] = 116951, - [SMALL_STATE(3231)] = 116968, - [SMALL_STATE(3232)] = 116985, - [SMALL_STATE(3233)] = 117002, - [SMALL_STATE(3234)] = 117019, - [SMALL_STATE(3235)] = 117036, - [SMALL_STATE(3236)] = 117053, - [SMALL_STATE(3237)] = 117070, - [SMALL_STATE(3238)] = 117087, - [SMALL_STATE(3239)] = 117104, - [SMALL_STATE(3240)] = 117121, - [SMALL_STATE(3241)] = 117138, - [SMALL_STATE(3242)] = 117155, - [SMALL_STATE(3243)] = 117172, - [SMALL_STATE(3244)] = 117189, - [SMALL_STATE(3245)] = 117206, - [SMALL_STATE(3246)] = 117223, - [SMALL_STATE(3247)] = 117240, - [SMALL_STATE(3248)] = 117257, - [SMALL_STATE(3249)] = 117274, - [SMALL_STATE(3250)] = 117291, - [SMALL_STATE(3251)] = 117308, - [SMALL_STATE(3252)] = 117325, - [SMALL_STATE(3253)] = 117342, - [SMALL_STATE(3254)] = 117359, - [SMALL_STATE(3255)] = 117376, - [SMALL_STATE(3256)] = 117393, - [SMALL_STATE(3257)] = 117410, - [SMALL_STATE(3258)] = 117427, - [SMALL_STATE(3259)] = 117444, - [SMALL_STATE(3260)] = 117461, - [SMALL_STATE(3261)] = 117478, - [SMALL_STATE(3262)] = 117495, - [SMALL_STATE(3263)] = 117512, - [SMALL_STATE(3264)] = 117529, - [SMALL_STATE(3265)] = 117546, - [SMALL_STATE(3266)] = 117563, - [SMALL_STATE(3267)] = 117580, - [SMALL_STATE(3268)] = 117597, - [SMALL_STATE(3269)] = 117614, - [SMALL_STATE(3270)] = 117631, - [SMALL_STATE(3271)] = 117648, - [SMALL_STATE(3272)] = 117665, - [SMALL_STATE(3273)] = 117682, - [SMALL_STATE(3274)] = 117699, - [SMALL_STATE(3275)] = 117716, - [SMALL_STATE(3276)] = 117733, - [SMALL_STATE(3277)] = 117750, - [SMALL_STATE(3278)] = 117767, - [SMALL_STATE(3279)] = 117784, - [SMALL_STATE(3280)] = 117801, - [SMALL_STATE(3281)] = 117818, - [SMALL_STATE(3282)] = 117835, - [SMALL_STATE(3283)] = 117852, - [SMALL_STATE(3284)] = 117869, - [SMALL_STATE(3285)] = 117886, - [SMALL_STATE(3286)] = 117903, - [SMALL_STATE(3287)] = 117920, - [SMALL_STATE(3288)] = 117937, - [SMALL_STATE(3289)] = 117954, - [SMALL_STATE(3290)] = 117971, - [SMALL_STATE(3291)] = 117988, - [SMALL_STATE(3292)] = 118005, - [SMALL_STATE(3293)] = 118022, - [SMALL_STATE(3294)] = 118039, - [SMALL_STATE(3295)] = 118056, - [SMALL_STATE(3296)] = 118073, - [SMALL_STATE(3297)] = 118090, - [SMALL_STATE(3298)] = 118107, - [SMALL_STATE(3299)] = 118124, - [SMALL_STATE(3300)] = 118141, - [SMALL_STATE(3301)] = 118158, - [SMALL_STATE(3302)] = 118175, - [SMALL_STATE(3303)] = 118192, - [SMALL_STATE(3304)] = 118209, - [SMALL_STATE(3305)] = 118226, - [SMALL_STATE(3306)] = 118243, - [SMALL_STATE(3307)] = 118260, - [SMALL_STATE(3308)] = 118277, - [SMALL_STATE(3309)] = 118294, - [SMALL_STATE(3310)] = 118311, - [SMALL_STATE(3311)] = 118328, - [SMALL_STATE(3312)] = 118345, - [SMALL_STATE(3313)] = 118362, - [SMALL_STATE(3314)] = 118379, - [SMALL_STATE(3315)] = 118383, - [SMALL_STATE(3316)] = 118387, - [SMALL_STATE(3317)] = 118391, + [SMALL_STATE(300)] = 0, + [SMALL_STATE(301)] = 77, + [SMALL_STATE(302)] = 154, + [SMALL_STATE(303)] = 229, + [SMALL_STATE(304)] = 304, + [SMALL_STATE(305)] = 432, + [SMALL_STATE(306)] = 506, + [SMALL_STATE(307)] = 580, + [SMALL_STATE(308)] = 654, + [SMALL_STATE(309)] = 728, + [SMALL_STATE(310)] = 802, + [SMALL_STATE(311)] = 876, + [SMALL_STATE(312)] = 1004, + [SMALL_STATE(313)] = 1078, + [SMALL_STATE(314)] = 1206, + [SMALL_STATE(315)] = 1334, + [SMALL_STATE(316)] = 1462, + [SMALL_STATE(317)] = 1590, + [SMALL_STATE(318)] = 1718, + [SMALL_STATE(319)] = 1846, + [SMALL_STATE(320)] = 1920, + [SMALL_STATE(321)] = 1994, + [SMALL_STATE(322)] = 2068, + [SMALL_STATE(323)] = 2142, + [SMALL_STATE(324)] = 2216, + [SMALL_STATE(325)] = 2344, + [SMALL_STATE(326)] = 2472, + [SMALL_STATE(327)] = 2546, + [SMALL_STATE(328)] = 2620, + [SMALL_STATE(329)] = 2694, + [SMALL_STATE(330)] = 2768, + [SMALL_STATE(331)] = 2896, + [SMALL_STATE(332)] = 2970, + [SMALL_STATE(333)] = 3098, + [SMALL_STATE(334)] = 3226, + [SMALL_STATE(335)] = 3354, + [SMALL_STATE(336)] = 3428, + [SMALL_STATE(337)] = 3556, + [SMALL_STATE(338)] = 3684, + [SMALL_STATE(339)] = 3758, + [SMALL_STATE(340)] = 3832, + [SMALL_STATE(341)] = 3960, + [SMALL_STATE(342)] = 4034, + [SMALL_STATE(343)] = 4111, + [SMALL_STATE(344)] = 4188, + [SMALL_STATE(345)] = 4271, + [SMALL_STATE(346)] = 4354, + [SMALL_STATE(347)] = 4476, + [SMALL_STATE(348)] = 4597, + [SMALL_STATE(349)] = 4718, + [SMALL_STATE(350)] = 4839, + [SMALL_STATE(351)] = 4912, + [SMALL_STATE(352)] = 5033, + [SMALL_STATE(353)] = 5154, + [SMALL_STATE(354)] = 5229, + [SMALL_STATE(355)] = 5303, + [SMALL_STATE(356)] = 5385, + [SMALL_STATE(357)] = 5461, + [SMALL_STATE(358)] = 5543, + [SMALL_STATE(359)] = 5625, + [SMALL_STATE(360)] = 5707, + [SMALL_STATE(361)] = 5789, + [SMALL_STATE(362)] = 5869, + [SMALL_STATE(363)] = 5951, + [SMALL_STATE(364)] = 6027, + [SMALL_STATE(365)] = 6109, + [SMALL_STATE(366)] = 6185, + [SMALL_STATE(367)] = 6255, + [SMALL_STATE(368)] = 6325, + [SMALL_STATE(369)] = 6395, + [SMALL_STATE(370)] = 6467, + [SMALL_STATE(371)] = 6545, + [SMALL_STATE(372)] = 6660, + [SMALL_STATE(373)] = 6775, + [SMALL_STATE(374)] = 6888, + [SMALL_STATE(375)] = 7003, + [SMALL_STATE(376)] = 7118, + [SMALL_STATE(377)] = 7233, + [SMALL_STATE(378)] = 7301, + [SMALL_STATE(379)] = 7369, + [SMALL_STATE(380)] = 7481, + [SMALL_STATE(381)] = 7549, + [SMALL_STATE(382)] = 7661, + [SMALL_STATE(383)] = 7773, + [SMALL_STATE(384)] = 7841, + [SMALL_STATE(385)] = 7907, + [SMALL_STATE(386)] = 7973, + [SMALL_STATE(387)] = 8085, + [SMALL_STATE(388)] = 8197, + [SMALL_STATE(389)] = 8306, + [SMALL_STATE(390)] = 8369, + [SMALL_STATE(391)] = 8478, + [SMALL_STATE(392)] = 8587, + [SMALL_STATE(393)] = 8696, + [SMALL_STATE(394)] = 8805, + [SMALL_STATE(395)] = 8914, + [SMALL_STATE(396)] = 9023, + [SMALL_STATE(397)] = 9132, + [SMALL_STATE(398)] = 9241, + [SMALL_STATE(399)] = 9350, + [SMALL_STATE(400)] = 9459, + [SMALL_STATE(401)] = 9568, + [SMALL_STATE(402)] = 9677, + [SMALL_STATE(403)] = 9786, + [SMALL_STATE(404)] = 9895, + [SMALL_STATE(405)] = 10004, + [SMALL_STATE(406)] = 10113, + [SMALL_STATE(407)] = 10222, + [SMALL_STATE(408)] = 10331, + [SMALL_STATE(409)] = 10440, + [SMALL_STATE(410)] = 10549, + [SMALL_STATE(411)] = 10658, + [SMALL_STATE(412)] = 10767, + [SMALL_STATE(413)] = 10876, + [SMALL_STATE(414)] = 10985, + [SMALL_STATE(415)] = 11094, + [SMALL_STATE(416)] = 11203, + [SMALL_STATE(417)] = 11312, + [SMALL_STATE(418)] = 11421, + [SMALL_STATE(419)] = 11530, + [SMALL_STATE(420)] = 11639, + [SMALL_STATE(421)] = 11748, + [SMALL_STATE(422)] = 11857, + [SMALL_STATE(423)] = 11966, + [SMALL_STATE(424)] = 12075, + [SMALL_STATE(425)] = 12184, + [SMALL_STATE(426)] = 12293, + [SMALL_STATE(427)] = 12402, + [SMALL_STATE(428)] = 12465, + [SMALL_STATE(429)] = 12574, + [SMALL_STATE(430)] = 12683, + [SMALL_STATE(431)] = 12792, + [SMALL_STATE(432)] = 12901, + [SMALL_STATE(433)] = 13010, + [SMALL_STATE(434)] = 13119, + [SMALL_STATE(435)] = 13228, + [SMALL_STATE(436)] = 13337, + [SMALL_STATE(437)] = 13446, + [SMALL_STATE(438)] = 13555, + [SMALL_STATE(439)] = 13664, + [SMALL_STATE(440)] = 13773, + [SMALL_STATE(441)] = 13882, + [SMALL_STATE(442)] = 13991, + [SMALL_STATE(443)] = 14100, + [SMALL_STATE(444)] = 14209, + [SMALL_STATE(445)] = 14318, + [SMALL_STATE(446)] = 14427, + [SMALL_STATE(447)] = 14536, + [SMALL_STATE(448)] = 14645, + [SMALL_STATE(449)] = 14754, + [SMALL_STATE(450)] = 14863, + [SMALL_STATE(451)] = 14972, + [SMALL_STATE(452)] = 15081, + [SMALL_STATE(453)] = 15190, + [SMALL_STATE(454)] = 15299, + [SMALL_STATE(455)] = 15408, + [SMALL_STATE(456)] = 15517, + [SMALL_STATE(457)] = 15626, + [SMALL_STATE(458)] = 15735, + [SMALL_STATE(459)] = 15844, + [SMALL_STATE(460)] = 15953, + [SMALL_STATE(461)] = 16062, + [SMALL_STATE(462)] = 16171, + [SMALL_STATE(463)] = 16280, + [SMALL_STATE(464)] = 16389, + [SMALL_STATE(465)] = 16454, + [SMALL_STATE(466)] = 16563, + [SMALL_STATE(467)] = 16672, + [SMALL_STATE(468)] = 16781, + [SMALL_STATE(469)] = 16890, + [SMALL_STATE(470)] = 16999, + [SMALL_STATE(471)] = 17108, + [SMALL_STATE(472)] = 17217, + [SMALL_STATE(473)] = 17326, + [SMALL_STATE(474)] = 17435, + [SMALL_STATE(475)] = 17544, + [SMALL_STATE(476)] = 17653, + [SMALL_STATE(477)] = 17762, + [SMALL_STATE(478)] = 17871, + [SMALL_STATE(479)] = 17980, + [SMALL_STATE(480)] = 18089, + [SMALL_STATE(481)] = 18198, + [SMALL_STATE(482)] = 18307, + [SMALL_STATE(483)] = 18416, + [SMALL_STATE(484)] = 18525, + [SMALL_STATE(485)] = 18634, + [SMALL_STATE(486)] = 18699, + [SMALL_STATE(487)] = 18808, + [SMALL_STATE(488)] = 18917, + [SMALL_STATE(489)] = 19026, + [SMALL_STATE(490)] = 19135, + [SMALL_STATE(491)] = 19244, + [SMALL_STATE(492)] = 19353, + [SMALL_STATE(493)] = 19462, + [SMALL_STATE(494)] = 19571, + [SMALL_STATE(495)] = 19680, + [SMALL_STATE(496)] = 19789, + [SMALL_STATE(497)] = 19898, + [SMALL_STATE(498)] = 20007, + [SMALL_STATE(499)] = 20116, + [SMALL_STATE(500)] = 20225, + [SMALL_STATE(501)] = 20334, + [SMALL_STATE(502)] = 20443, + [SMALL_STATE(503)] = 20552, + [SMALL_STATE(504)] = 20661, + [SMALL_STATE(505)] = 20770, + [SMALL_STATE(506)] = 20879, + [SMALL_STATE(507)] = 20988, + [SMALL_STATE(508)] = 21097, + [SMALL_STATE(509)] = 21206, + [SMALL_STATE(510)] = 21315, + [SMALL_STATE(511)] = 21424, + [SMALL_STATE(512)] = 21533, + [SMALL_STATE(513)] = 21602, + [SMALL_STATE(514)] = 21711, + [SMALL_STATE(515)] = 21820, + [SMALL_STATE(516)] = 21929, + [SMALL_STATE(517)] = 21998, + [SMALL_STATE(518)] = 22107, + [SMALL_STATE(519)] = 22216, + [SMALL_STATE(520)] = 22325, + [SMALL_STATE(521)] = 22434, + [SMALL_STATE(522)] = 22543, + [SMALL_STATE(523)] = 22652, + [SMALL_STATE(524)] = 22761, + [SMALL_STATE(525)] = 22870, + [SMALL_STATE(526)] = 22933, + [SMALL_STATE(527)] = 22998, + [SMALL_STATE(528)] = 23107, + [SMALL_STATE(529)] = 23216, + [SMALL_STATE(530)] = 23325, + [SMALL_STATE(531)] = 23434, + [SMALL_STATE(532)] = 23543, + [SMALL_STATE(533)] = 23608, + [SMALL_STATE(534)] = 23717, + [SMALL_STATE(535)] = 23826, + [SMALL_STATE(536)] = 23935, + [SMALL_STATE(537)] = 24044, + [SMALL_STATE(538)] = 24153, + [SMALL_STATE(539)] = 24262, + [SMALL_STATE(540)] = 24371, + [SMALL_STATE(541)] = 24480, + [SMALL_STATE(542)] = 24589, + [SMALL_STATE(543)] = 24698, + [SMALL_STATE(544)] = 24763, + [SMALL_STATE(545)] = 24872, + [SMALL_STATE(546)] = 24981, + [SMALL_STATE(547)] = 25090, + [SMALL_STATE(548)] = 25152, + [SMALL_STATE(549)] = 25214, + [SMALL_STATE(550)] = 25276, + [SMALL_STATE(551)] = 25338, + [SMALL_STATE(552)] = 25400, + [SMALL_STATE(553)] = 25462, + [SMALL_STATE(554)] = 25524, + [SMALL_STATE(555)] = 25586, + [SMALL_STATE(556)] = 25648, + [SMALL_STATE(557)] = 25710, + [SMALL_STATE(558)] = 25772, + [SMALL_STATE(559)] = 25834, + [SMALL_STATE(560)] = 25896, + [SMALL_STATE(561)] = 25958, + [SMALL_STATE(562)] = 26020, + [SMALL_STATE(563)] = 26082, + [SMALL_STATE(564)] = 26144, + [SMALL_STATE(565)] = 26206, + [SMALL_STATE(566)] = 26268, + [SMALL_STATE(567)] = 26330, + [SMALL_STATE(568)] = 26392, + [SMALL_STATE(569)] = 26454, + [SMALL_STATE(570)] = 26516, + [SMALL_STATE(571)] = 26578, + [SMALL_STATE(572)] = 26640, + [SMALL_STATE(573)] = 26702, + [SMALL_STATE(574)] = 26764, + [SMALL_STATE(575)] = 26826, + [SMALL_STATE(576)] = 26909, + [SMALL_STATE(577)] = 26992, + [SMALL_STATE(578)] = 27075, + [SMALL_STATE(579)] = 27154, + [SMALL_STATE(580)] = 27237, + [SMALL_STATE(581)] = 27318, + [SMALL_STATE(582)] = 27391, + [SMALL_STATE(583)] = 27468, + [SMALL_STATE(584)] = 27551, + [SMALL_STATE(585)] = 27634, + [SMALL_STATE(586)] = 27730, + [SMALL_STATE(587)] = 27826, + [SMALL_STATE(588)] = 27922, + [SMALL_STATE(589)] = 28018, + [SMALL_STATE(590)] = 28114, + [SMALL_STATE(591)] = 28210, + [SMALL_STATE(592)] = 28306, + [SMALL_STATE(593)] = 28402, + [SMALL_STATE(594)] = 28498, + [SMALL_STATE(595)] = 28594, + [SMALL_STATE(596)] = 28690, + [SMALL_STATE(597)] = 28786, + [SMALL_STATE(598)] = 28855, + [SMALL_STATE(599)] = 28924, + [SMALL_STATE(600)] = 29000, + [SMALL_STATE(601)] = 29074, + [SMALL_STATE(602)] = 29150, + [SMALL_STATE(603)] = 29216, + [SMALL_STATE(604)] = 29292, + [SMALL_STATE(605)] = 29368, + [SMALL_STATE(606)] = 29444, + [SMALL_STATE(607)] = 29520, + [SMALL_STATE(608)] = 29596, + [SMALL_STATE(609)] = 29672, + [SMALL_STATE(610)] = 29748, + [SMALL_STATE(611)] = 29824, + [SMALL_STATE(612)] = 29896, + [SMALL_STATE(613)] = 29972, + [SMALL_STATE(614)] = 30044, + [SMALL_STATE(615)] = 30110, + [SMALL_STATE(616)] = 30184, + [SMALL_STATE(617)] = 30260, + [SMALL_STATE(618)] = 30330, + [SMALL_STATE(619)] = 30400, + [SMALL_STATE(620)] = 30476, + [SMALL_STATE(621)] = 30552, + [SMALL_STATE(622)] = 30641, + [SMALL_STATE(623)] = 30730, + [SMALL_STATE(624)] = 30819, + [SMALL_STATE(625)] = 30908, + [SMALL_STATE(626)] = 30997, + [SMALL_STATE(627)] = 31086, + [SMALL_STATE(628)] = 31146, + [SMALL_STATE(629)] = 31204, + [SMALL_STATE(630)] = 31264, + [SMALL_STATE(631)] = 31324, + [SMALL_STATE(632)] = 31398, + [SMALL_STATE(633)] = 31456, + [SMALL_STATE(634)] = 31513, + [SMALL_STATE(635)] = 31570, + [SMALL_STATE(636)] = 31627, + [SMALL_STATE(637)] = 31682, + [SMALL_STATE(638)] = 31737, + [SMALL_STATE(639)] = 31794, + [SMALL_STATE(640)] = 31851, + [SMALL_STATE(641)] = 31906, + [SMALL_STATE(642)] = 31960, + [SMALL_STATE(643)] = 32014, + [SMALL_STATE(644)] = 32068, + [SMALL_STATE(645)] = 32122, + [SMALL_STATE(646)] = 32176, + [SMALL_STATE(647)] = 32230, + [SMALL_STATE(648)] = 32284, + [SMALL_STATE(649)] = 32338, + [SMALL_STATE(650)] = 32392, + [SMALL_STATE(651)] = 32446, + [SMALL_STATE(652)] = 32500, + [SMALL_STATE(653)] = 32554, + [SMALL_STATE(654)] = 32608, + [SMALL_STATE(655)] = 32662, + [SMALL_STATE(656)] = 32716, + [SMALL_STATE(657)] = 32770, + [SMALL_STATE(658)] = 32842, + [SMALL_STATE(659)] = 32896, + [SMALL_STATE(660)] = 32950, + [SMALL_STATE(661)] = 33004, + [SMALL_STATE(662)] = 33058, + [SMALL_STATE(663)] = 33112, + [SMALL_STATE(664)] = 33166, + [SMALL_STATE(665)] = 33220, + [SMALL_STATE(666)] = 33274, + [SMALL_STATE(667)] = 33328, + [SMALL_STATE(668)] = 33382, + [SMALL_STATE(669)] = 33436, + [SMALL_STATE(670)] = 33490, + [SMALL_STATE(671)] = 33551, + [SMALL_STATE(672)] = 33614, + [SMALL_STATE(673)] = 33677, + [SMALL_STATE(674)] = 33738, + [SMALL_STATE(675)] = 33804, + [SMALL_STATE(676)] = 33874, + [SMALL_STATE(677)] = 33932, + [SMALL_STATE(678)] = 33998, + [SMALL_STATE(679)] = 34050, + [SMALL_STATE(680)] = 34108, + [SMALL_STATE(681)] = 34170, + [SMALL_STATE(682)] = 34242, + [SMALL_STATE(683)] = 34310, + [SMALL_STATE(684)] = 34374, + [SMALL_STATE(685)] = 34440, + [SMALL_STATE(686)] = 34506, + [SMALL_STATE(687)] = 34556, + [SMALL_STATE(688)] = 34626, + [SMALL_STATE(689)] = 34696, + [SMALL_STATE(690)] = 34766, + [SMALL_STATE(691)] = 34832, + [SMALL_STATE(692)] = 34898, + [SMALL_STATE(693)] = 34964, + [SMALL_STATE(694)] = 35022, + [SMALL_STATE(695)] = 35082, + [SMALL_STATE(696)] = 35152, + [SMALL_STATE(697)] = 35218, + [SMALL_STATE(698)] = 35278, + [SMALL_STATE(699)] = 35348, + [SMALL_STATE(700)] = 35412, + [SMALL_STATE(701)] = 35469, + [SMALL_STATE(702)] = 35544, + [SMALL_STATE(703)] = 35603, + [SMALL_STATE(704)] = 35652, + [SMALL_STATE(705)] = 35715, + [SMALL_STATE(706)] = 35778, + [SMALL_STATE(707)] = 35841, + [SMALL_STATE(708)] = 35904, + [SMALL_STATE(709)] = 35967, + [SMALL_STATE(710)] = 36026, + [SMALL_STATE(711)] = 36081, + [SMALL_STATE(712)] = 36142, + [SMALL_STATE(713)] = 36205, + [SMALL_STATE(714)] = 36268, + [SMALL_STATE(715)] = 36343, + [SMALL_STATE(716)] = 36402, + [SMALL_STATE(717)] = 36454, + [SMALL_STATE(718)] = 36504, + [SMALL_STATE(719)] = 36556, + [SMALL_STATE(720)] = 36616, + [SMALL_STATE(721)] = 36674, + [SMALL_STATE(722)] = 36728, + [SMALL_STATE(723)] = 36778, + [SMALL_STATE(724)] = 36830, + [SMALL_STATE(725)] = 36880, + [SMALL_STATE(726)] = 36936, + [SMALL_STATE(727)] = 36990, + [SMALL_STATE(728)] = 37050, + [SMALL_STATE(729)] = 37114, + [SMALL_STATE(730)] = 37178, + [SMALL_STATE(731)] = 37242, + [SMALL_STATE(732)] = 37310, + [SMALL_STATE(733)] = 37362, + [SMALL_STATE(734)] = 37416, + [SMALL_STATE(735)] = 37476, + [SMALL_STATE(736)] = 37540, + [SMALL_STATE(737)] = 37594, + [SMALL_STATE(738)] = 37658, + [SMALL_STATE(739)] = 37710, + [SMALL_STATE(740)] = 37774, + [SMALL_STATE(741)] = 37838, + [SMALL_STATE(742)] = 37890, + [SMALL_STATE(743)] = 37952, + [SMALL_STATE(744)] = 38004, + [SMALL_STATE(745)] = 38053, + [SMALL_STATE(746)] = 38102, + [SMALL_STATE(747)] = 38169, + [SMALL_STATE(748)] = 38236, + [SMALL_STATE(749)] = 38303, + [SMALL_STATE(750)] = 38370, + [SMALL_STATE(751)] = 38437, + [SMALL_STATE(752)] = 38504, + [SMALL_STATE(753)] = 38567, + [SMALL_STATE(754)] = 38624, + [SMALL_STATE(755)] = 38685, + [SMALL_STATE(756)] = 38752, + [SMALL_STATE(757)] = 38819, + [SMALL_STATE(758)] = 38886, + [SMALL_STATE(759)] = 38953, + [SMALL_STATE(760)] = 39000, + [SMALL_STATE(761)] = 39049, + [SMALL_STATE(762)] = 39114, + [SMALL_STATE(763)] = 39163, + [SMALL_STATE(764)] = 39210, + [SMALL_STATE(765)] = 39259, + [SMALL_STATE(766)] = 39326, + [SMALL_STATE(767)] = 39373, + [SMALL_STATE(768)] = 39420, + [SMALL_STATE(769)] = 39469, + [SMALL_STATE(770)] = 39516, + [SMALL_STATE(771)] = 39563, + [SMALL_STATE(772)] = 39612, + [SMALL_STATE(773)] = 39661, + [SMALL_STATE(774)] = 39710, + [SMALL_STATE(775)] = 39759, + [SMALL_STATE(776)] = 39825, + [SMALL_STATE(777)] = 39891, + [SMALL_STATE(778)] = 39937, + [SMALL_STATE(779)] = 40003, + [SMALL_STATE(780)] = 40069, + [SMALL_STATE(781)] = 40127, + [SMALL_STATE(782)] = 40193, + [SMALL_STATE(783)] = 40259, + [SMALL_STATE(784)] = 40325, + [SMALL_STATE(785)] = 40371, + [SMALL_STATE(786)] = 40417, + [SMALL_STATE(787)] = 40463, + [SMALL_STATE(788)] = 40509, + [SMALL_STATE(789)] = 40555, + [SMALL_STATE(790)] = 40601, + [SMALL_STATE(791)] = 40647, + [SMALL_STATE(792)] = 40693, + [SMALL_STATE(793)] = 40739, + [SMALL_STATE(794)] = 40785, + [SMALL_STATE(795)] = 40831, + [SMALL_STATE(796)] = 40877, + [SMALL_STATE(797)] = 40923, + [SMALL_STATE(798)] = 40969, + [SMALL_STATE(799)] = 41015, + [SMALL_STATE(800)] = 41081, + [SMALL_STATE(801)] = 41147, + [SMALL_STATE(802)] = 41213, + [SMALL_STATE(803)] = 41259, + [SMALL_STATE(804)] = 41325, + [SMALL_STATE(805)] = 41371, + [SMALL_STATE(806)] = 41437, + [SMALL_STATE(807)] = 41503, + [SMALL_STATE(808)] = 41569, + [SMALL_STATE(809)] = 41635, + [SMALL_STATE(810)] = 41701, + [SMALL_STATE(811)] = 41747, + [SMALL_STATE(812)] = 41793, + [SMALL_STATE(813)] = 41859, + [SMALL_STATE(814)] = 41905, + [SMALL_STATE(815)] = 41955, + [SMALL_STATE(816)] = 42005, + [SMALL_STATE(817)] = 42071, + [SMALL_STATE(818)] = 42117, + [SMALL_STATE(819)] = 42163, + [SMALL_STATE(820)] = 42209, + [SMALL_STATE(821)] = 42259, + [SMALL_STATE(822)] = 42305, + [SMALL_STATE(823)] = 42371, + [SMALL_STATE(824)] = 42437, + [SMALL_STATE(825)] = 42483, + [SMALL_STATE(826)] = 42529, + [SMALL_STATE(827)] = 42595, + [SMALL_STATE(828)] = 42661, + [SMALL_STATE(829)] = 42719, + [SMALL_STATE(830)] = 42765, + [SMALL_STATE(831)] = 42811, + [SMALL_STATE(832)] = 42859, + [SMALL_STATE(833)] = 42925, + [SMALL_STATE(834)] = 42973, + [SMALL_STATE(835)] = 43021, + [SMALL_STATE(836)] = 43087, + [SMALL_STATE(837)] = 43153, + [SMALL_STATE(838)] = 43219, + [SMALL_STATE(839)] = 43285, + [SMALL_STATE(840)] = 43351, + [SMALL_STATE(841)] = 43417, + [SMALL_STATE(842)] = 43483, + [SMALL_STATE(843)] = 43549, + [SMALL_STATE(844)] = 43615, + [SMALL_STATE(845)] = 43681, + [SMALL_STATE(846)] = 43747, + [SMALL_STATE(847)] = 43813, + [SMALL_STATE(848)] = 43879, + [SMALL_STATE(849)] = 43945, + [SMALL_STATE(850)] = 44011, + [SMALL_STATE(851)] = 44077, + [SMALL_STATE(852)] = 44143, + [SMALL_STATE(853)] = 44209, + [SMALL_STATE(854)] = 44275, + [SMALL_STATE(855)] = 44341, + [SMALL_STATE(856)] = 44407, + [SMALL_STATE(857)] = 44453, + [SMALL_STATE(858)] = 44503, + [SMALL_STATE(859)] = 44547, + [SMALL_STATE(860)] = 44593, + [SMALL_STATE(861)] = 44639, + [SMALL_STATE(862)] = 44683, + [SMALL_STATE(863)] = 44727, + [SMALL_STATE(864)] = 44772, + [SMALL_STATE(865)] = 44819, + [SMALL_STATE(866)] = 44870, + [SMALL_STATE(867)] = 44913, + [SMALL_STATE(868)] = 44966, + [SMALL_STATE(869)] = 45013, + [SMALL_STATE(870)] = 45056, + [SMALL_STATE(871)] = 45107, + [SMALL_STATE(872)] = 45150, + [SMALL_STATE(873)] = 45193, + [SMALL_STATE(874)] = 45236, + [SMALL_STATE(875)] = 45279, + [SMALL_STATE(876)] = 45322, + [SMALL_STATE(877)] = 45365, + [SMALL_STATE(878)] = 45408, + [SMALL_STATE(879)] = 45451, + [SMALL_STATE(880)] = 45494, + [SMALL_STATE(881)] = 45537, + [SMALL_STATE(882)] = 45588, + [SMALL_STATE(883)] = 45631, + [SMALL_STATE(884)] = 45684, + [SMALL_STATE(885)] = 45727, + [SMALL_STATE(886)] = 45770, + [SMALL_STATE(887)] = 45813, + [SMALL_STATE(888)] = 45856, + [SMALL_STATE(889)] = 45899, + [SMALL_STATE(890)] = 45942, + [SMALL_STATE(891)] = 45985, + [SMALL_STATE(892)] = 46028, + [SMALL_STATE(893)] = 46071, + [SMALL_STATE(894)] = 46114, + [SMALL_STATE(895)] = 46163, + [SMALL_STATE(896)] = 46206, + [SMALL_STATE(897)] = 46249, + [SMALL_STATE(898)] = 46294, + [SMALL_STATE(899)] = 46339, + [SMALL_STATE(900)] = 46382, + [SMALL_STATE(901)] = 46425, + [SMALL_STATE(902)] = 46468, + [SMALL_STATE(903)] = 46514, + [SMALL_STATE(904)] = 46558, + [SMALL_STATE(905)] = 46602, + [SMALL_STATE(906)] = 46646, + [SMALL_STATE(907)] = 46690, + [SMALL_STATE(908)] = 46734, + [SMALL_STATE(909)] = 46778, + [SMALL_STATE(910)] = 46822, + [SMALL_STATE(911)] = 46866, + [SMALL_STATE(912)] = 46910, + [SMALL_STATE(913)] = 46954, + [SMALL_STATE(914)] = 47000, + [SMALL_STATE(915)] = 47044, + [SMALL_STATE(916)] = 47088, + [SMALL_STATE(917)] = 47132, + [SMALL_STATE(918)] = 47176, + [SMALL_STATE(919)] = 47220, + [SMALL_STATE(920)] = 47264, + [SMALL_STATE(921)] = 47308, + [SMALL_STATE(922)] = 47352, + [SMALL_STATE(923)] = 47396, + [SMALL_STATE(924)] = 47440, + [SMALL_STATE(925)] = 47484, + [SMALL_STATE(926)] = 47528, + [SMALL_STATE(927)] = 47572, + [SMALL_STATE(928)] = 47616, + [SMALL_STATE(929)] = 47660, + [SMALL_STATE(930)] = 47704, + [SMALL_STATE(931)] = 47748, + [SMALL_STATE(932)] = 47792, + [SMALL_STATE(933)] = 47834, + [SMALL_STATE(934)] = 47918, + [SMALL_STATE(935)] = 47960, + [SMALL_STATE(936)] = 48002, + [SMALL_STATE(937)] = 48044, + [SMALL_STATE(938)] = 48088, + [SMALL_STATE(939)] = 48132, + [SMALL_STATE(940)] = 48176, + [SMALL_STATE(941)] = 48220, + [SMALL_STATE(942)] = 48262, + [SMALL_STATE(943)] = 48304, + [SMALL_STATE(944)] = 48346, + [SMALL_STATE(945)] = 48390, + [SMALL_STATE(946)] = 48434, + [SMALL_STATE(947)] = 48478, + [SMALL_STATE(948)] = 48522, + [SMALL_STATE(949)] = 48566, + [SMALL_STATE(950)] = 48610, + [SMALL_STATE(951)] = 48654, + [SMALL_STATE(952)] = 48698, + [SMALL_STATE(953)] = 48742, + [SMALL_STATE(954)] = 48786, + [SMALL_STATE(955)] = 48830, + [SMALL_STATE(956)] = 48874, + [SMALL_STATE(957)] = 48918, + [SMALL_STATE(958)] = 48962, + [SMALL_STATE(959)] = 49006, + [SMALL_STATE(960)] = 49050, + [SMALL_STATE(961)] = 49094, + [SMALL_STATE(962)] = 49138, + [SMALL_STATE(963)] = 49182, + [SMALL_STATE(964)] = 49226, + [SMALL_STATE(965)] = 49270, + [SMALL_STATE(966)] = 49314, + [SMALL_STATE(967)] = 49358, + [SMALL_STATE(968)] = 49402, + [SMALL_STATE(969)] = 49446, + [SMALL_STATE(970)] = 49490, + [SMALL_STATE(971)] = 49534, + [SMALL_STATE(972)] = 49578, + [SMALL_STATE(973)] = 49622, + [SMALL_STATE(974)] = 49706, + [SMALL_STATE(975)] = 49750, + [SMALL_STATE(976)] = 49794, + [SMALL_STATE(977)] = 49838, + [SMALL_STATE(978)] = 49882, + [SMALL_STATE(979)] = 49926, + [SMALL_STATE(980)] = 49970, + [SMALL_STATE(981)] = 50014, + [SMALL_STATE(982)] = 50098, + [SMALL_STATE(983)] = 50142, + [SMALL_STATE(984)] = 50186, + [SMALL_STATE(985)] = 50230, + [SMALL_STATE(986)] = 50274, + [SMALL_STATE(987)] = 50318, + [SMALL_STATE(988)] = 50362, + [SMALL_STATE(989)] = 50406, + [SMALL_STATE(990)] = 50450, + [SMALL_STATE(991)] = 50494, + [SMALL_STATE(992)] = 50538, + [SMALL_STATE(993)] = 50582, + [SMALL_STATE(994)] = 50626, + [SMALL_STATE(995)] = 50670, + [SMALL_STATE(996)] = 50714, + [SMALL_STATE(997)] = 50758, + [SMALL_STATE(998)] = 50802, + [SMALL_STATE(999)] = 50846, + [SMALL_STATE(1000)] = 50890, + [SMALL_STATE(1001)] = 50934, + [SMALL_STATE(1002)] = 50978, + [SMALL_STATE(1003)] = 51022, + [SMALL_STATE(1004)] = 51066, + [SMALL_STATE(1005)] = 51110, + [SMALL_STATE(1006)] = 51154, + [SMALL_STATE(1007)] = 51198, + [SMALL_STATE(1008)] = 51242, + [SMALL_STATE(1009)] = 51286, + [SMALL_STATE(1010)] = 51330, + [SMALL_STATE(1011)] = 51374, + [SMALL_STATE(1012)] = 51418, + [SMALL_STATE(1013)] = 51502, + [SMALL_STATE(1014)] = 51546, + [SMALL_STATE(1015)] = 51590, + [SMALL_STATE(1016)] = 51634, + [SMALL_STATE(1017)] = 51678, + [SMALL_STATE(1018)] = 51720, + [SMALL_STATE(1019)] = 51762, + [SMALL_STATE(1020)] = 51804, + [SMALL_STATE(1021)] = 51846, + [SMALL_STATE(1022)] = 51930, + [SMALL_STATE(1023)] = 51974, + [SMALL_STATE(1024)] = 52016, + [SMALL_STATE(1025)] = 52058, + [SMALL_STATE(1026)] = 52100, + [SMALL_STATE(1027)] = 52142, + [SMALL_STATE(1028)] = 52184, + [SMALL_STATE(1029)] = 52226, + [SMALL_STATE(1030)] = 52268, + [SMALL_STATE(1031)] = 52310, + [SMALL_STATE(1032)] = 52352, + [SMALL_STATE(1033)] = 52394, + [SMALL_STATE(1034)] = 52436, + [SMALL_STATE(1035)] = 52478, + [SMALL_STATE(1036)] = 52520, + [SMALL_STATE(1037)] = 52562, + [SMALL_STATE(1038)] = 52604, + [SMALL_STATE(1039)] = 52646, + [SMALL_STATE(1040)] = 52688, + [SMALL_STATE(1041)] = 52730, + [SMALL_STATE(1042)] = 52772, + [SMALL_STATE(1043)] = 52814, + [SMALL_STATE(1044)] = 52856, + [SMALL_STATE(1045)] = 52898, + [SMALL_STATE(1046)] = 52940, + [SMALL_STATE(1047)] = 52982, + [SMALL_STATE(1048)] = 53024, + [SMALL_STATE(1049)] = 53066, + [SMALL_STATE(1050)] = 53150, + [SMALL_STATE(1051)] = 53192, + [SMALL_STATE(1052)] = 53234, + [SMALL_STATE(1053)] = 53276, + [SMALL_STATE(1054)] = 53318, + [SMALL_STATE(1055)] = 53360, + [SMALL_STATE(1056)] = 53402, + [SMALL_STATE(1057)] = 53486, + [SMALL_STATE(1058)] = 53528, + [SMALL_STATE(1059)] = 53570, + [SMALL_STATE(1060)] = 53612, + [SMALL_STATE(1061)] = 53654, + [SMALL_STATE(1062)] = 53696, + [SMALL_STATE(1063)] = 53738, + [SMALL_STATE(1064)] = 53780, + [SMALL_STATE(1065)] = 53822, + [SMALL_STATE(1066)] = 53864, + [SMALL_STATE(1067)] = 53906, + [SMALL_STATE(1068)] = 53948, + [SMALL_STATE(1069)] = 53990, + [SMALL_STATE(1070)] = 54032, + [SMALL_STATE(1071)] = 54074, + [SMALL_STATE(1072)] = 54116, + [SMALL_STATE(1073)] = 54158, + [SMALL_STATE(1074)] = 54200, + [SMALL_STATE(1075)] = 54242, + [SMALL_STATE(1076)] = 54284, + [SMALL_STATE(1077)] = 54326, + [SMALL_STATE(1078)] = 54368, + [SMALL_STATE(1079)] = 54410, + [SMALL_STATE(1080)] = 54452, + [SMALL_STATE(1081)] = 54494, + [SMALL_STATE(1082)] = 54536, + [SMALL_STATE(1083)] = 54578, + [SMALL_STATE(1084)] = 54620, + [SMALL_STATE(1085)] = 54704, + [SMALL_STATE(1086)] = 54746, + [SMALL_STATE(1087)] = 54788, + [SMALL_STATE(1088)] = 54830, + [SMALL_STATE(1089)] = 54872, + [SMALL_STATE(1090)] = 54914, + [SMALL_STATE(1091)] = 54956, + [SMALL_STATE(1092)] = 54998, + [SMALL_STATE(1093)] = 55040, + [SMALL_STATE(1094)] = 55082, + [SMALL_STATE(1095)] = 55124, + [SMALL_STATE(1096)] = 55168, + [SMALL_STATE(1097)] = 55252, + [SMALL_STATE(1098)] = 55296, + [SMALL_STATE(1099)] = 55380, + [SMALL_STATE(1100)] = 55424, + [SMALL_STATE(1101)] = 55468, + [SMALL_STATE(1102)] = 55512, + [SMALL_STATE(1103)] = 55553, + [SMALL_STATE(1104)] = 55596, + [SMALL_STATE(1105)] = 55639, + [SMALL_STATE(1106)] = 55682, + [SMALL_STATE(1107)] = 55725, + [SMALL_STATE(1108)] = 55766, + [SMALL_STATE(1109)] = 55807, + [SMALL_STATE(1110)] = 55850, + [SMALL_STATE(1111)] = 55893, + [SMALL_STATE(1112)] = 55936, + [SMALL_STATE(1113)] = 55979, + [SMALL_STATE(1114)] = 56022, + [SMALL_STATE(1115)] = 56065, + [SMALL_STATE(1116)] = 56106, + [SMALL_STATE(1117)] = 56147, + [SMALL_STATE(1118)] = 56188, + [SMALL_STATE(1119)] = 56229, + [SMALL_STATE(1120)] = 56270, + [SMALL_STATE(1121)] = 56313, + [SMALL_STATE(1122)] = 56354, + [SMALL_STATE(1123)] = 56395, + [SMALL_STATE(1124)] = 56438, + [SMALL_STATE(1125)] = 56481, + [SMALL_STATE(1126)] = 56524, + [SMALL_STATE(1127)] = 56565, + [SMALL_STATE(1128)] = 56606, + [SMALL_STATE(1129)] = 56649, + [SMALL_STATE(1130)] = 56690, + [SMALL_STATE(1131)] = 56733, + [SMALL_STATE(1132)] = 56776, + [SMALL_STATE(1133)] = 56817, + [SMALL_STATE(1134)] = 56860, + [SMALL_STATE(1135)] = 56903, + [SMALL_STATE(1136)] = 56946, + [SMALL_STATE(1137)] = 56987, + [SMALL_STATE(1138)] = 57030, + [SMALL_STATE(1139)] = 57071, + [SMALL_STATE(1140)] = 57112, + [SMALL_STATE(1141)] = 57155, + [SMALL_STATE(1142)] = 57198, + [SMALL_STATE(1143)] = 57241, + [SMALL_STATE(1144)] = 57282, + [SMALL_STATE(1145)] = 57325, + [SMALL_STATE(1146)] = 57368, + [SMALL_STATE(1147)] = 57409, + [SMALL_STATE(1148)] = 57450, + [SMALL_STATE(1149)] = 57491, + [SMALL_STATE(1150)] = 57532, + [SMALL_STATE(1151)] = 57575, + [SMALL_STATE(1152)] = 57618, + [SMALL_STATE(1153)] = 57661, + [SMALL_STATE(1154)] = 57702, + [SMALL_STATE(1155)] = 57745, + [SMALL_STATE(1156)] = 57788, + [SMALL_STATE(1157)] = 57829, + [SMALL_STATE(1158)] = 57872, + [SMALL_STATE(1159)] = 57915, + [SMALL_STATE(1160)] = 57956, + [SMALL_STATE(1161)] = 57997, + [SMALL_STATE(1162)] = 58048, + [SMALL_STATE(1163)] = 58089, + [SMALL_STATE(1164)] = 58132, + [SMALL_STATE(1165)] = 58175, + [SMALL_STATE(1166)] = 58218, + [SMALL_STATE(1167)] = 58261, + [SMALL_STATE(1168)] = 58304, + [SMALL_STATE(1169)] = 58345, + [SMALL_STATE(1170)] = 58388, + [SMALL_STATE(1171)] = 58431, + [SMALL_STATE(1172)] = 58474, + [SMALL_STATE(1173)] = 58517, + [SMALL_STATE(1174)] = 58558, + [SMALL_STATE(1175)] = 58601, + [SMALL_STATE(1176)] = 58644, + [SMALL_STATE(1177)] = 58687, + [SMALL_STATE(1178)] = 58728, + [SMALL_STATE(1179)] = 58771, + [SMALL_STATE(1180)] = 58814, + [SMALL_STATE(1181)] = 58857, + [SMALL_STATE(1182)] = 58900, + [SMALL_STATE(1183)] = 58941, + [SMALL_STATE(1184)] = 58982, + [SMALL_STATE(1185)] = 59025, + [SMALL_STATE(1186)] = 59066, + [SMALL_STATE(1187)] = 59109, + [SMALL_STATE(1188)] = 59152, + [SMALL_STATE(1189)] = 59193, + [SMALL_STATE(1190)] = 59234, + [SMALL_STATE(1191)] = 59277, + [SMALL_STATE(1192)] = 59318, + [SMALL_STATE(1193)] = 59359, + [SMALL_STATE(1194)] = 59402, + [SMALL_STATE(1195)] = 59443, + [SMALL_STATE(1196)] = 59486, + [SMALL_STATE(1197)] = 59529, + [SMALL_STATE(1198)] = 59570, + [SMALL_STATE(1199)] = 59613, + [SMALL_STATE(1200)] = 59654, + [SMALL_STATE(1201)] = 59695, + [SMALL_STATE(1202)] = 59738, + [SMALL_STATE(1203)] = 59781, + [SMALL_STATE(1204)] = 59822, + [SMALL_STATE(1205)] = 59863, + [SMALL_STATE(1206)] = 59906, + [SMALL_STATE(1207)] = 59949, + [SMALL_STATE(1208)] = 59992, + [SMALL_STATE(1209)] = 60035, + [SMALL_STATE(1210)] = 60078, + [SMALL_STATE(1211)] = 60121, + [SMALL_STATE(1212)] = 60164, + [SMALL_STATE(1213)] = 60207, + [SMALL_STATE(1214)] = 60250, + [SMALL_STATE(1215)] = 60291, + [SMALL_STATE(1216)] = 60332, + [SMALL_STATE(1217)] = 60375, + [SMALL_STATE(1218)] = 60418, + [SMALL_STATE(1219)] = 60461, + [SMALL_STATE(1220)] = 60504, + [SMALL_STATE(1221)] = 60547, + [SMALL_STATE(1222)] = 60590, + [SMALL_STATE(1223)] = 60631, + [SMALL_STATE(1224)] = 60674, + [SMALL_STATE(1225)] = 60717, + [SMALL_STATE(1226)] = 60760, + [SMALL_STATE(1227)] = 60801, + [SMALL_STATE(1228)] = 60842, + [SMALL_STATE(1229)] = 60883, + [SMALL_STATE(1230)] = 60924, + [SMALL_STATE(1231)] = 60965, + [SMALL_STATE(1232)] = 61008, + [SMALL_STATE(1233)] = 61049, + [SMALL_STATE(1234)] = 61092, + [SMALL_STATE(1235)] = 61135, + [SMALL_STATE(1236)] = 61178, + [SMALL_STATE(1237)] = 61221, + [SMALL_STATE(1238)] = 61264, + [SMALL_STATE(1239)] = 61307, + [SMALL_STATE(1240)] = 61348, + [SMALL_STATE(1241)] = 61391, + [SMALL_STATE(1242)] = 61434, + [SMALL_STATE(1243)] = 61477, + [SMALL_STATE(1244)] = 61520, + [SMALL_STATE(1245)] = 61561, + [SMALL_STATE(1246)] = 61604, + [SMALL_STATE(1247)] = 61647, + [SMALL_STATE(1248)] = 61690, + [SMALL_STATE(1249)] = 61731, + [SMALL_STATE(1250)] = 61772, + [SMALL_STATE(1251)] = 61815, + [SMALL_STATE(1252)] = 61858, + [SMALL_STATE(1253)] = 61899, + [SMALL_STATE(1254)] = 61940, + [SMALL_STATE(1255)] = 61981, + [SMALL_STATE(1256)] = 62022, + [SMALL_STATE(1257)] = 62063, + [SMALL_STATE(1258)] = 62106, + [SMALL_STATE(1259)] = 62149, + [SMALL_STATE(1260)] = 62190, + [SMALL_STATE(1261)] = 62231, + [SMALL_STATE(1262)] = 62274, + [SMALL_STATE(1263)] = 62317, + [SMALL_STATE(1264)] = 62358, + [SMALL_STATE(1265)] = 62401, + [SMALL_STATE(1266)] = 62444, + [SMALL_STATE(1267)] = 62485, + [SMALL_STATE(1268)] = 62526, + [SMALL_STATE(1269)] = 62569, + [SMALL_STATE(1270)] = 62610, + [SMALL_STATE(1271)] = 62651, + [SMALL_STATE(1272)] = 62692, + [SMALL_STATE(1273)] = 62735, + [SMALL_STATE(1274)] = 62778, + [SMALL_STATE(1275)] = 62819, + [SMALL_STATE(1276)] = 62860, + [SMALL_STATE(1277)] = 62901, + [SMALL_STATE(1278)] = 62942, + [SMALL_STATE(1279)] = 62983, + [SMALL_STATE(1280)] = 63024, + [SMALL_STATE(1281)] = 63067, + [SMALL_STATE(1282)] = 63108, + [SMALL_STATE(1283)] = 63149, + [SMALL_STATE(1284)] = 63192, + [SMALL_STATE(1285)] = 63233, + [SMALL_STATE(1286)] = 63274, + [SMALL_STATE(1287)] = 63315, + [SMALL_STATE(1288)] = 63356, + [SMALL_STATE(1289)] = 63397, + [SMALL_STATE(1290)] = 63438, + [SMALL_STATE(1291)] = 63479, + [SMALL_STATE(1292)] = 63520, + [SMALL_STATE(1293)] = 63561, + [SMALL_STATE(1294)] = 63604, + [SMALL_STATE(1295)] = 63645, + [SMALL_STATE(1296)] = 63688, + [SMALL_STATE(1297)] = 63729, + [SMALL_STATE(1298)] = 63770, + [SMALL_STATE(1299)] = 63813, + [SMALL_STATE(1300)] = 63856, + [SMALL_STATE(1301)] = 63899, + [SMALL_STATE(1302)] = 63942, + [SMALL_STATE(1303)] = 63983, + [SMALL_STATE(1304)] = 64026, + [SMALL_STATE(1305)] = 64067, + [SMALL_STATE(1306)] = 64108, + [SMALL_STATE(1307)] = 64151, + [SMALL_STATE(1308)] = 64194, + [SMALL_STATE(1309)] = 64235, + [SMALL_STATE(1310)] = 64276, + [SMALL_STATE(1311)] = 64317, + [SMALL_STATE(1312)] = 64358, + [SMALL_STATE(1313)] = 64399, + [SMALL_STATE(1314)] = 64440, + [SMALL_STATE(1315)] = 64481, + [SMALL_STATE(1316)] = 64522, + [SMALL_STATE(1317)] = 64563, + [SMALL_STATE(1318)] = 64604, + [SMALL_STATE(1319)] = 64683, + [SMALL_STATE(1320)] = 64724, + [SMALL_STATE(1321)] = 64767, + [SMALL_STATE(1322)] = 64808, + [SMALL_STATE(1323)] = 64849, + [SMALL_STATE(1324)] = 64890, + [SMALL_STATE(1325)] = 64933, + [SMALL_STATE(1326)] = 64976, + [SMALL_STATE(1327)] = 65017, + [SMALL_STATE(1328)] = 65060, + [SMALL_STATE(1329)] = 65103, + [SMALL_STATE(1330)] = 65144, + [SMALL_STATE(1331)] = 65187, + [SMALL_STATE(1332)] = 65230, + [SMALL_STATE(1333)] = 65273, + [SMALL_STATE(1334)] = 65314, + [SMALL_STATE(1335)] = 65355, + [SMALL_STATE(1336)] = 65398, + [SMALL_STATE(1337)] = 65439, + [SMALL_STATE(1338)] = 65482, + [SMALL_STATE(1339)] = 65525, + [SMALL_STATE(1340)] = 65568, + [SMALL_STATE(1341)] = 65611, + [SMALL_STATE(1342)] = 65654, + [SMALL_STATE(1343)] = 65697, + [SMALL_STATE(1344)] = 65738, + [SMALL_STATE(1345)] = 65781, + [SMALL_STATE(1346)] = 65822, + [SMALL_STATE(1347)] = 65865, + [SMALL_STATE(1348)] = 65906, + [SMALL_STATE(1349)] = 65947, + [SMALL_STATE(1350)] = 65990, + [SMALL_STATE(1351)] = 66033, + [SMALL_STATE(1352)] = 66076, + [SMALL_STATE(1353)] = 66119, + [SMALL_STATE(1354)] = 66160, + [SMALL_STATE(1355)] = 66201, + [SMALL_STATE(1356)] = 66244, + [SMALL_STATE(1357)] = 66287, + [SMALL_STATE(1358)] = 66330, + [SMALL_STATE(1359)] = 66371, + [SMALL_STATE(1360)] = 66412, + [SMALL_STATE(1361)] = 66455, + [SMALL_STATE(1362)] = 66496, + [SMALL_STATE(1363)] = 66537, + [SMALL_STATE(1364)] = 66578, + [SMALL_STATE(1365)] = 66619, + [SMALL_STATE(1366)] = 66660, + [SMALL_STATE(1367)] = 66703, + [SMALL_STATE(1368)] = 66744, + [SMALL_STATE(1369)] = 66785, + [SMALL_STATE(1370)] = 66826, + [SMALL_STATE(1371)] = 66869, + [SMALL_STATE(1372)] = 66912, + [SMALL_STATE(1373)] = 66953, + [SMALL_STATE(1374)] = 66996, + [SMALL_STATE(1375)] = 67039, + [SMALL_STATE(1376)] = 67082, + [SMALL_STATE(1377)] = 67125, + [SMALL_STATE(1378)] = 67166, + [SMALL_STATE(1379)] = 67209, + [SMALL_STATE(1380)] = 67250, + [SMALL_STATE(1381)] = 67293, + [SMALL_STATE(1382)] = 67336, + [SMALL_STATE(1383)] = 67377, + [SMALL_STATE(1384)] = 67418, + [SMALL_STATE(1385)] = 67459, + [SMALL_STATE(1386)] = 67502, + [SMALL_STATE(1387)] = 67543, + [SMALL_STATE(1388)] = 67584, + [SMALL_STATE(1389)] = 67631, + [SMALL_STATE(1390)] = 67672, + [SMALL_STATE(1391)] = 67713, + [SMALL_STATE(1392)] = 67754, + [SMALL_STATE(1393)] = 67795, + [SMALL_STATE(1394)] = 67836, + [SMALL_STATE(1395)] = 67877, + [SMALL_STATE(1396)] = 67918, + [SMALL_STATE(1397)] = 67961, + [SMALL_STATE(1398)] = 68004, + [SMALL_STATE(1399)] = 68045, + [SMALL_STATE(1400)] = 68086, + [SMALL_STATE(1401)] = 68127, + [SMALL_STATE(1402)] = 68168, + [SMALL_STATE(1403)] = 68209, + [SMALL_STATE(1404)] = 68252, + [SMALL_STATE(1405)] = 68293, + [SMALL_STATE(1406)] = 68336, + [SMALL_STATE(1407)] = 68377, + [SMALL_STATE(1408)] = 68418, + [SMALL_STATE(1409)] = 68459, + [SMALL_STATE(1410)] = 68500, + [SMALL_STATE(1411)] = 68541, + [SMALL_STATE(1412)] = 68584, + [SMALL_STATE(1413)] = 68627, + [SMALL_STATE(1414)] = 68668, + [SMALL_STATE(1415)] = 68711, + [SMALL_STATE(1416)] = 68752, + [SMALL_STATE(1417)] = 68801, + [SMALL_STATE(1418)] = 68844, + [SMALL_STATE(1419)] = 68885, + [SMALL_STATE(1420)] = 68926, + [SMALL_STATE(1421)] = 68967, + [SMALL_STATE(1422)] = 69010, + [SMALL_STATE(1423)] = 69051, + [SMALL_STATE(1424)] = 69094, + [SMALL_STATE(1425)] = 69137, + [SMALL_STATE(1426)] = 69180, + [SMALL_STATE(1427)] = 69223, + [SMALL_STATE(1428)] = 69266, + [SMALL_STATE(1429)] = 69309, + [SMALL_STATE(1430)] = 69352, + [SMALL_STATE(1431)] = 69395, + [SMALL_STATE(1432)] = 69438, + [SMALL_STATE(1433)] = 69481, + [SMALL_STATE(1434)] = 69522, + [SMALL_STATE(1435)] = 69563, + [SMALL_STATE(1436)] = 69604, + [SMALL_STATE(1437)] = 69645, + [SMALL_STATE(1438)] = 69686, + [SMALL_STATE(1439)] = 69727, + [SMALL_STATE(1440)] = 69768, + [SMALL_STATE(1441)] = 69809, + [SMALL_STATE(1442)] = 69850, + [SMALL_STATE(1443)] = 69891, + [SMALL_STATE(1444)] = 69934, + [SMALL_STATE(1445)] = 69975, + [SMALL_STATE(1446)] = 70018, + [SMALL_STATE(1447)] = 70059, + [SMALL_STATE(1448)] = 70102, + [SMALL_STATE(1449)] = 70143, + [SMALL_STATE(1450)] = 70184, + [SMALL_STATE(1451)] = 70227, + [SMALL_STATE(1452)] = 70270, + [SMALL_STATE(1453)] = 70311, + [SMALL_STATE(1454)] = 70354, + [SMALL_STATE(1455)] = 70395, + [SMALL_STATE(1456)] = 70438, + [SMALL_STATE(1457)] = 70481, + [SMALL_STATE(1458)] = 70524, + [SMALL_STATE(1459)] = 70567, + [SMALL_STATE(1460)] = 70608, + [SMALL_STATE(1461)] = 70649, + [SMALL_STATE(1462)] = 70690, + [SMALL_STATE(1463)] = 70731, + [SMALL_STATE(1464)] = 70774, + [SMALL_STATE(1465)] = 70817, + [SMALL_STATE(1466)] = 70860, + [SMALL_STATE(1467)] = 70903, + [SMALL_STATE(1468)] = 70944, + [SMALL_STATE(1469)] = 70985, + [SMALL_STATE(1470)] = 71026, + [SMALL_STATE(1471)] = 71067, + [SMALL_STATE(1472)] = 71108, + [SMALL_STATE(1473)] = 71151, + [SMALL_STATE(1474)] = 71194, + [SMALL_STATE(1475)] = 71235, + [SMALL_STATE(1476)] = 71278, + [SMALL_STATE(1477)] = 71356, + [SMALL_STATE(1478)] = 71424, + [SMALL_STATE(1479)] = 71502, + [SMALL_STATE(1480)] = 71580, + [SMALL_STATE(1481)] = 71648, + [SMALL_STATE(1482)] = 71726, + [SMALL_STATE(1483)] = 71804, + [SMALL_STATE(1484)] = 71882, + [SMALL_STATE(1485)] = 71960, + [SMALL_STATE(1486)] = 72038, + [SMALL_STATE(1487)] = 72116, + [SMALL_STATE(1488)] = 72194, + [SMALL_STATE(1489)] = 72267, + [SMALL_STATE(1490)] = 72339, + [SMALL_STATE(1491)] = 72411, + [SMALL_STATE(1492)] = 72483, + [SMALL_STATE(1493)] = 72519, + [SMALL_STATE(1494)] = 72591, + [SMALL_STATE(1495)] = 72663, + [SMALL_STATE(1496)] = 72703, + [SMALL_STATE(1497)] = 72775, + [SMALL_STATE(1498)] = 72847, + [SMALL_STATE(1499)] = 72919, + [SMALL_STATE(1500)] = 72991, + [SMALL_STATE(1501)] = 73027, + [SMALL_STATE(1502)] = 73063, + [SMALL_STATE(1503)] = 73135, + [SMALL_STATE(1504)] = 73171, + [SMALL_STATE(1505)] = 73207, + [SMALL_STATE(1506)] = 73250, + [SMALL_STATE(1507)] = 73319, + [SMALL_STATE(1508)] = 73386, + [SMALL_STATE(1509)] = 73429, + [SMALL_STATE(1510)] = 73468, + [SMALL_STATE(1511)] = 73537, + [SMALL_STATE(1512)] = 73580, + [SMALL_STATE(1513)] = 73649, + [SMALL_STATE(1514)] = 73692, + [SMALL_STATE(1515)] = 73735, + [SMALL_STATE(1516)] = 73778, + [SMALL_STATE(1517)] = 73821, + [SMALL_STATE(1518)] = 73890, + [SMALL_STATE(1519)] = 73933, + [SMALL_STATE(1520)] = 74002, + [SMALL_STATE(1521)] = 74071, + [SMALL_STATE(1522)] = 74134, + [SMALL_STATE(1523)] = 74177, + [SMALL_STATE(1524)] = 74246, + [SMALL_STATE(1525)] = 74289, + [SMALL_STATE(1526)] = 74332, + [SMALL_STATE(1527)] = 74375, + [SMALL_STATE(1528)] = 74444, + [SMALL_STATE(1529)] = 74513, + [SMALL_STATE(1530)] = 74582, + [SMALL_STATE(1531)] = 74625, + [SMALL_STATE(1532)] = 74668, + [SMALL_STATE(1533)] = 74711, + [SMALL_STATE(1534)] = 74780, + [SMALL_STATE(1535)] = 74849, + [SMALL_STATE(1536)] = 74918, + [SMALL_STATE(1537)] = 74987, + [SMALL_STATE(1538)] = 75056, + [SMALL_STATE(1539)] = 75099, + [SMALL_STATE(1540)] = 75142, + [SMALL_STATE(1541)] = 75211, + [SMALL_STATE(1542)] = 75280, + [SMALL_STATE(1543)] = 75349, + [SMALL_STATE(1544)] = 75418, + [SMALL_STATE(1545)] = 75487, + [SMALL_STATE(1546)] = 75551, + [SMALL_STATE(1547)] = 75615, + [SMALL_STATE(1548)] = 75675, + [SMALL_STATE(1549)] = 75735, + [SMALL_STATE(1550)] = 75798, + [SMALL_STATE(1551)] = 75861, + [SMALL_STATE(1552)] = 75924, + [SMALL_STATE(1553)] = 75987, + [SMALL_STATE(1554)] = 76050, + [SMALL_STATE(1555)] = 76113, + [SMALL_STATE(1556)] = 76176, + [SMALL_STATE(1557)] = 76239, + [SMALL_STATE(1558)] = 76302, + [SMALL_STATE(1559)] = 76365, + [SMALL_STATE(1560)] = 76428, + [SMALL_STATE(1561)] = 76491, + [SMALL_STATE(1562)] = 76554, + [SMALL_STATE(1563)] = 76617, + [SMALL_STATE(1564)] = 76680, + [SMALL_STATE(1565)] = 76743, + [SMALL_STATE(1566)] = 76806, + [SMALL_STATE(1567)] = 76869, + [SMALL_STATE(1568)] = 76932, + [SMALL_STATE(1569)] = 76995, + [SMALL_STATE(1570)] = 77058, + [SMALL_STATE(1571)] = 77093, + [SMALL_STATE(1572)] = 77156, + [SMALL_STATE(1573)] = 77219, + [SMALL_STATE(1574)] = 77282, + [SMALL_STATE(1575)] = 77345, + [SMALL_STATE(1576)] = 77408, + [SMALL_STATE(1577)] = 77471, + [SMALL_STATE(1578)] = 77534, + [SMALL_STATE(1579)] = 77597, + [SMALL_STATE(1580)] = 77660, + [SMALL_STATE(1581)] = 77723, + [SMALL_STATE(1582)] = 77786, + [SMALL_STATE(1583)] = 77849, + [SMALL_STATE(1584)] = 77912, + [SMALL_STATE(1585)] = 77975, + [SMALL_STATE(1586)] = 78038, + [SMALL_STATE(1587)] = 78101, + [SMALL_STATE(1588)] = 78164, + [SMALL_STATE(1589)] = 78227, + [SMALL_STATE(1590)] = 78290, + [SMALL_STATE(1591)] = 78353, + [SMALL_STATE(1592)] = 78416, + [SMALL_STATE(1593)] = 78479, + [SMALL_STATE(1594)] = 78542, + [SMALL_STATE(1595)] = 78605, + [SMALL_STATE(1596)] = 78668, + [SMALL_STATE(1597)] = 78731, + [SMALL_STATE(1598)] = 78794, + [SMALL_STATE(1599)] = 78857, + [SMALL_STATE(1600)] = 78920, + [SMALL_STATE(1601)] = 78983, + [SMALL_STATE(1602)] = 79046, + [SMALL_STATE(1603)] = 79109, + [SMALL_STATE(1604)] = 79172, + [SMALL_STATE(1605)] = 79235, + [SMALL_STATE(1606)] = 79298, + [SMALL_STATE(1607)] = 79361, + [SMALL_STATE(1608)] = 79424, + [SMALL_STATE(1609)] = 79487, + [SMALL_STATE(1610)] = 79550, + [SMALL_STATE(1611)] = 79609, + [SMALL_STATE(1612)] = 79672, + [SMALL_STATE(1613)] = 79735, + [SMALL_STATE(1614)] = 79798, + [SMALL_STATE(1615)] = 79861, + [SMALL_STATE(1616)] = 79924, + [SMALL_STATE(1617)] = 79987, + [SMALL_STATE(1618)] = 80050, + [SMALL_STATE(1619)] = 80113, + [SMALL_STATE(1620)] = 80176, + [SMALL_STATE(1621)] = 80235, + [SMALL_STATE(1622)] = 80298, + [SMALL_STATE(1623)] = 80356, + [SMALL_STATE(1624)] = 80414, + [SMALL_STATE(1625)] = 80470, + [SMALL_STATE(1626)] = 80508, + [SMALL_STATE(1627)] = 80564, + [SMALL_STATE(1628)] = 80622, + [SMALL_STATE(1629)] = 80678, + [SMALL_STATE(1630)] = 80728, + [SMALL_STATE(1631)] = 80786, + [SMALL_STATE(1632)] = 80844, + [SMALL_STATE(1633)] = 80900, + [SMALL_STATE(1634)] = 80958, + [SMALL_STATE(1635)] = 81016, + [SMALL_STATE(1636)] = 81071, + [SMALL_STATE(1637)] = 81126, + [SMALL_STATE(1638)] = 81179, + [SMALL_STATE(1639)] = 81232, + [SMALL_STATE(1640)] = 81287, + [SMALL_STATE(1641)] = 81342, + [SMALL_STATE(1642)] = 81396, + [SMALL_STATE(1643)] = 81428, + [SMALL_STATE(1644)] = 81470, + [SMALL_STATE(1645)] = 81502, + [SMALL_STATE(1646)] = 81548, + [SMALL_STATE(1647)] = 81602, + [SMALL_STATE(1648)] = 81654, + [SMALL_STATE(1649)] = 81708, + [SMALL_STATE(1650)] = 81740, + [SMALL_STATE(1651)] = 81786, + [SMALL_STATE(1652)] = 81840, + [SMALL_STATE(1653)] = 81892, + [SMALL_STATE(1654)] = 81939, + [SMALL_STATE(1655)] = 81988, + [SMALL_STATE(1656)] = 82035, + [SMALL_STATE(1657)] = 82082, + [SMALL_STATE(1658)] = 82137, + [SMALL_STATE(1659)] = 82184, + [SMALL_STATE(1660)] = 82231, + [SMALL_STATE(1661)] = 82278, + [SMALL_STATE(1662)] = 82325, + [SMALL_STATE(1663)] = 82374, + [SMALL_STATE(1664)] = 82423, + [SMALL_STATE(1665)] = 82470, + [SMALL_STATE(1666)] = 82519, + [SMALL_STATE(1667)] = 82566, + [SMALL_STATE(1668)] = 82613, + [SMALL_STATE(1669)] = 82662, + [SMALL_STATE(1670)] = 82709, + [SMALL_STATE(1671)] = 82756, + [SMALL_STATE(1672)] = 82803, + [SMALL_STATE(1673)] = 82850, + [SMALL_STATE(1674)] = 82895, + [SMALL_STATE(1675)] = 82942, + [SMALL_STATE(1676)] = 82975, + [SMALL_STATE(1677)] = 83022, + [SMALL_STATE(1678)] = 83069, + [SMALL_STATE(1679)] = 83118, + [SMALL_STATE(1680)] = 83165, + [SMALL_STATE(1681)] = 83212, + [SMALL_STATE(1682)] = 83259, + [SMALL_STATE(1683)] = 83306, + [SMALL_STATE(1684)] = 83353, + [SMALL_STATE(1685)] = 83400, + [SMALL_STATE(1686)] = 83447, + [SMALL_STATE(1687)] = 83496, + [SMALL_STATE(1688)] = 83551, + [SMALL_STATE(1689)] = 83600, + [SMALL_STATE(1690)] = 83655, + [SMALL_STATE(1691)] = 83710, + [SMALL_STATE(1692)] = 83756, + [SMALL_STATE(1693)] = 83796, + [SMALL_STATE(1694)] = 83836, + [SMALL_STATE(1695)] = 83872, + [SMALL_STATE(1696)] = 83912, + [SMALL_STATE(1697)] = 83958, + [SMALL_STATE(1698)] = 84004, + [SMALL_STATE(1699)] = 84050, + [SMALL_STATE(1700)] = 84096, + [SMALL_STATE(1701)] = 84142, + [SMALL_STATE(1702)] = 84188, + [SMALL_STATE(1703)] = 84236, + [SMALL_STATE(1704)] = 84282, + [SMALL_STATE(1705)] = 84328, + [SMALL_STATE(1706)] = 84372, + [SMALL_STATE(1707)] = 84420, + [SMALL_STATE(1708)] = 84468, + [SMALL_STATE(1709)] = 84514, + [SMALL_STATE(1710)] = 84560, + [SMALL_STATE(1711)] = 84608, + [SMALL_STATE(1712)] = 84644, + [SMALL_STATE(1713)] = 84690, + [SMALL_STATE(1714)] = 84733, + [SMALL_STATE(1715)] = 84776, + [SMALL_STATE(1716)] = 84819, + [SMALL_STATE(1717)] = 84868, + [SMALL_STATE(1718)] = 84911, + [SMALL_STATE(1719)] = 84954, + [SMALL_STATE(1720)] = 84995, + [SMALL_STATE(1721)] = 85024, + [SMALL_STATE(1722)] = 85067, + [SMALL_STATE(1723)] = 85110, + [SMALL_STATE(1724)] = 85153, + [SMALL_STATE(1725)] = 85196, + [SMALL_STATE(1726)] = 85239, + [SMALL_STATE(1727)] = 85282, + [SMALL_STATE(1728)] = 85331, + [SMALL_STATE(1729)] = 85366, + [SMALL_STATE(1730)] = 85415, + [SMALL_STATE(1731)] = 85458, + [SMALL_STATE(1732)] = 85507, + [SMALL_STATE(1733)] = 85556, + [SMALL_STATE(1734)] = 85605, + [SMALL_STATE(1735)] = 85648, + [SMALL_STATE(1736)] = 85691, + [SMALL_STATE(1737)] = 85734, + [SMALL_STATE(1738)] = 85777, + [SMALL_STATE(1739)] = 85820, + [SMALL_STATE(1740)] = 85863, + [SMALL_STATE(1741)] = 85912, + [SMALL_STATE(1742)] = 85955, + [SMALL_STATE(1743)] = 85998, + [SMALL_STATE(1744)] = 86033, + [SMALL_STATE(1745)] = 86076, + [SMALL_STATE(1746)] = 86119, + [SMALL_STATE(1747)] = 86162, + [SMALL_STATE(1748)] = 86193, + [SMALL_STATE(1749)] = 86236, + [SMALL_STATE(1750)] = 86279, + [SMALL_STATE(1751)] = 86322, + [SMALL_STATE(1752)] = 86365, + [SMALL_STATE(1753)] = 86408, + [SMALL_STATE(1754)] = 86451, + [SMALL_STATE(1755)] = 86494, + [SMALL_STATE(1756)] = 86537, + [SMALL_STATE(1757)] = 86580, + [SMALL_STATE(1758)] = 86623, + [SMALL_STATE(1759)] = 86658, + [SMALL_STATE(1760)] = 86701, + [SMALL_STATE(1761)] = 86744, + [SMALL_STATE(1762)] = 86787, + [SMALL_STATE(1763)] = 86836, + [SMALL_STATE(1764)] = 86879, + [SMALL_STATE(1765)] = 86912, + [SMALL_STATE(1766)] = 86961, + [SMALL_STATE(1767)] = 86994, + [SMALL_STATE(1768)] = 87043, + [SMALL_STATE(1769)] = 87086, + [SMALL_STATE(1770)] = 87120, + [SMALL_STATE(1771)] = 87158, + [SMALL_STATE(1772)] = 87204, + [SMALL_STATE(1773)] = 87246, + [SMALL_STATE(1774)] = 87292, + [SMALL_STATE(1775)] = 87322, + [SMALL_STATE(1776)] = 87368, + [SMALL_STATE(1777)] = 87410, + [SMALL_STATE(1778)] = 87452, + [SMALL_STATE(1779)] = 87490, + [SMALL_STATE(1780)] = 87524, + [SMALL_STATE(1781)] = 87570, + [SMALL_STATE(1782)] = 87616, + [SMALL_STATE(1783)] = 87662, + [SMALL_STATE(1784)] = 87704, + [SMALL_STATE(1785)] = 87750, + [SMALL_STATE(1786)] = 87796, + [SMALL_STATE(1787)] = 87842, + [SMALL_STATE(1788)] = 87884, + [SMALL_STATE(1789)] = 87922, + [SMALL_STATE(1790)] = 87964, + [SMALL_STATE(1791)] = 87994, + [SMALL_STATE(1792)] = 88040, + [SMALL_STATE(1793)] = 88070, + [SMALL_STATE(1794)] = 88116, + [SMALL_STATE(1795)] = 88162, + [SMALL_STATE(1796)] = 88190, + [SMALL_STATE(1797)] = 88222, + [SMALL_STATE(1798)] = 88251, + [SMALL_STATE(1799)] = 88290, + [SMALL_STATE(1800)] = 88337, + [SMALL_STATE(1801)] = 88366, + [SMALL_STATE(1802)] = 88413, + [SMALL_STATE(1803)] = 88448, + [SMALL_STATE(1804)] = 88495, + [SMALL_STATE(1805)] = 88542, + [SMALL_STATE(1806)] = 88581, + [SMALL_STATE(1807)] = 88628, + [SMALL_STATE(1808)] = 88663, + [SMALL_STATE(1809)] = 88710, + [SMALL_STATE(1810)] = 88757, + [SMALL_STATE(1811)] = 88804, + [SMALL_STATE(1812)] = 88833, + [SMALL_STATE(1813)] = 88880, + [SMALL_STATE(1814)] = 88927, + [SMALL_STATE(1815)] = 88974, + [SMALL_STATE(1816)] = 89021, + [SMALL_STATE(1817)] = 89052, + [SMALL_STATE(1818)] = 89099, + [SMALL_STATE(1819)] = 89146, + [SMALL_STATE(1820)] = 89193, + [SMALL_STATE(1821)] = 89240, + [SMALL_STATE(1822)] = 89277, + [SMALL_STATE(1823)] = 89324, + [SMALL_STATE(1824)] = 89353, + [SMALL_STATE(1825)] = 89382, + [SMALL_STATE(1826)] = 89421, + [SMALL_STATE(1827)] = 89468, + [SMALL_STATE(1828)] = 89515, + [SMALL_STATE(1829)] = 89550, + [SMALL_STATE(1830)] = 89579, + [SMALL_STATE(1831)] = 89618, + [SMALL_STATE(1832)] = 89645, + [SMALL_STATE(1833)] = 89692, + [SMALL_STATE(1834)] = 89739, + [SMALL_STATE(1835)] = 89768, + [SMALL_STATE(1836)] = 89805, + [SMALL_STATE(1837)] = 89834, + [SMALL_STATE(1838)] = 89881, + [SMALL_STATE(1839)] = 89920, + [SMALL_STATE(1840)] = 89967, + [SMALL_STATE(1841)] = 90006, + [SMALL_STATE(1842)] = 90035, + [SMALL_STATE(1843)] = 90082, + [SMALL_STATE(1844)] = 90129, + [SMALL_STATE(1845)] = 90176, + [SMALL_STATE(1846)] = 90205, + [SMALL_STATE(1847)] = 90234, + [SMALL_STATE(1848)] = 90265, + [SMALL_STATE(1849)] = 90294, + [SMALL_STATE(1850)] = 90341, + [SMALL_STATE(1851)] = 90370, + [SMALL_STATE(1852)] = 90417, + [SMALL_STATE(1853)] = 90464, + [SMALL_STATE(1854)] = 90493, + [SMALL_STATE(1855)] = 90540, + [SMALL_STATE(1856)] = 90567, + [SMALL_STATE(1857)] = 90614, + [SMALL_STATE(1858)] = 90653, + [SMALL_STATE(1859)] = 90700, + [SMALL_STATE(1860)] = 90747, + [SMALL_STATE(1861)] = 90774, + [SMALL_STATE(1862)] = 90821, + [SMALL_STATE(1863)] = 90868, + [SMALL_STATE(1864)] = 90915, + [SMALL_STATE(1865)] = 90962, + [SMALL_STATE(1866)] = 91001, + [SMALL_STATE(1867)] = 91048, + [SMALL_STATE(1868)] = 91095, + [SMALL_STATE(1869)] = 91142, + [SMALL_STATE(1870)] = 91189, + [SMALL_STATE(1871)] = 91228, + [SMALL_STATE(1872)] = 91275, + [SMALL_STATE(1873)] = 91302, + [SMALL_STATE(1874)] = 91349, + [SMALL_STATE(1875)] = 91396, + [SMALL_STATE(1876)] = 91435, + [SMALL_STATE(1877)] = 91472, + [SMALL_STATE(1878)] = 91519, + [SMALL_STATE(1879)] = 91546, + [SMALL_STATE(1880)] = 91593, + [SMALL_STATE(1881)] = 91640, + [SMALL_STATE(1882)] = 91677, + [SMALL_STATE(1883)] = 91724, + [SMALL_STATE(1884)] = 91771, + [SMALL_STATE(1885)] = 91818, + [SMALL_STATE(1886)] = 91857, + [SMALL_STATE(1887)] = 91896, + [SMALL_STATE(1888)] = 91936, + [SMALL_STATE(1889)] = 91976, + [SMALL_STATE(1890)] = 92016, + [SMALL_STATE(1891)] = 92056, + [SMALL_STATE(1892)] = 92096, + [SMALL_STATE(1893)] = 92130, + [SMALL_STATE(1894)] = 92156, + [SMALL_STATE(1895)] = 92196, + [SMALL_STATE(1896)] = 92236, + [SMALL_STATE(1897)] = 92272, + [SMALL_STATE(1898)] = 92304, + [SMALL_STATE(1899)] = 92340, + [SMALL_STATE(1900)] = 92384, + [SMALL_STATE(1901)] = 92428, + [SMALL_STATE(1902)] = 92468, + [SMALL_STATE(1903)] = 92496, + [SMALL_STATE(1904)] = 92536, + [SMALL_STATE(1905)] = 92578, + [SMALL_STATE(1906)] = 92618, + [SMALL_STATE(1907)] = 92654, + [SMALL_STATE(1908)] = 92680, + [SMALL_STATE(1909)] = 92714, + [SMALL_STATE(1910)] = 92754, + [SMALL_STATE(1911)] = 92794, + [SMALL_STATE(1912)] = 92830, + [SMALL_STATE(1913)] = 92870, + [SMALL_STATE(1914)] = 92910, + [SMALL_STATE(1915)] = 92946, + [SMALL_STATE(1916)] = 92988, + [SMALL_STATE(1917)] = 93032, + [SMALL_STATE(1918)] = 93072, + [SMALL_STATE(1919)] = 93112, + [SMALL_STATE(1920)] = 93152, + [SMALL_STATE(1921)] = 93182, + [SMALL_STATE(1922)] = 93208, + [SMALL_STATE(1923)] = 93244, + [SMALL_STATE(1924)] = 93284, + [SMALL_STATE(1925)] = 93324, + [SMALL_STATE(1926)] = 93364, + [SMALL_STATE(1927)] = 93404, + [SMALL_STATE(1928)] = 93440, + [SMALL_STATE(1929)] = 93470, + [SMALL_STATE(1930)] = 93504, + [SMALL_STATE(1931)] = 93544, + [SMALL_STATE(1932)] = 93584, + [SMALL_STATE(1933)] = 93612, + [SMALL_STATE(1934)] = 93648, + [SMALL_STATE(1935)] = 93676, + [SMALL_STATE(1936)] = 93720, + [SMALL_STATE(1937)] = 93764, + [SMALL_STATE(1938)] = 93808, + [SMALL_STATE(1939)] = 93848, + [SMALL_STATE(1940)] = 93890, + [SMALL_STATE(1941)] = 93932, + [SMALL_STATE(1942)] = 93972, + [SMALL_STATE(1943)] = 94014, + [SMALL_STATE(1944)] = 94050, + [SMALL_STATE(1945)] = 94083, + [SMALL_STATE(1946)] = 94108, + [SMALL_STATE(1947)] = 94141, + [SMALL_STATE(1948)] = 94174, + [SMALL_STATE(1949)] = 94207, + [SMALL_STATE(1950)] = 94240, + [SMALL_STATE(1951)] = 94273, + [SMALL_STATE(1952)] = 94306, + [SMALL_STATE(1953)] = 94331, + [SMALL_STATE(1954)] = 94358, + [SMALL_STATE(1955)] = 94389, + [SMALL_STATE(1956)] = 94416, + [SMALL_STATE(1957)] = 94449, + [SMALL_STATE(1958)] = 94482, + [SMALL_STATE(1959)] = 94515, + [SMALL_STATE(1960)] = 94548, + [SMALL_STATE(1961)] = 94573, + [SMALL_STATE(1962)] = 94606, + [SMALL_STATE(1963)] = 94637, + [SMALL_STATE(1964)] = 94670, + [SMALL_STATE(1965)] = 94703, + [SMALL_STATE(1966)] = 94736, + [SMALL_STATE(1967)] = 94765, + [SMALL_STATE(1968)] = 94798, + [SMALL_STATE(1969)] = 94827, + [SMALL_STATE(1970)] = 94860, + [SMALL_STATE(1971)] = 94889, + [SMALL_STATE(1972)] = 94922, + [SMALL_STATE(1973)] = 94951, + [SMALL_STATE(1974)] = 94984, + [SMALL_STATE(1975)] = 95021, + [SMALL_STATE(1976)] = 95054, + [SMALL_STATE(1977)] = 95091, + [SMALL_STATE(1978)] = 95124, + [SMALL_STATE(1979)] = 95157, + [SMALL_STATE(1980)] = 95184, + [SMALL_STATE(1981)] = 95217, + [SMALL_STATE(1982)] = 95250, + [SMALL_STATE(1983)] = 95283, + [SMALL_STATE(1984)] = 95316, + [SMALL_STATE(1985)] = 95349, + [SMALL_STATE(1986)] = 95376, + [SMALL_STATE(1987)] = 95409, + [SMALL_STATE(1988)] = 95442, + [SMALL_STATE(1989)] = 95475, + [SMALL_STATE(1990)] = 95508, + [SMALL_STATE(1991)] = 95541, + [SMALL_STATE(1992)] = 95574, + [SMALL_STATE(1993)] = 95607, + [SMALL_STATE(1994)] = 95636, + [SMALL_STATE(1995)] = 95669, + [SMALL_STATE(1996)] = 95702, + [SMALL_STATE(1997)] = 95735, + [SMALL_STATE(1998)] = 95766, + [SMALL_STATE(1999)] = 95799, + [SMALL_STATE(2000)] = 95826, + [SMALL_STATE(2001)] = 95859, + [SMALL_STATE(2002)] = 95892, + [SMALL_STATE(2003)] = 95925, + [SMALL_STATE(2004)] = 95952, + [SMALL_STATE(2005)] = 95985, + [SMALL_STATE(2006)] = 96018, + [SMALL_STATE(2007)] = 96051, + [SMALL_STATE(2008)] = 96084, + [SMALL_STATE(2009)] = 96117, + [SMALL_STATE(2010)] = 96150, + [SMALL_STATE(2011)] = 96183, + [SMALL_STATE(2012)] = 96210, + [SMALL_STATE(2013)] = 96238, + [SMALL_STATE(2014)] = 96274, + [SMALL_STATE(2015)] = 96310, + [SMALL_STATE(2016)] = 96348, + [SMALL_STATE(2017)] = 96384, + [SMALL_STATE(2018)] = 96420, + [SMALL_STATE(2019)] = 96452, + [SMALL_STATE(2020)] = 96488, + [SMALL_STATE(2021)] = 96518, + [SMALL_STATE(2022)] = 96554, + [SMALL_STATE(2023)] = 96590, + [SMALL_STATE(2024)] = 96626, + [SMALL_STATE(2025)] = 96662, + [SMALL_STATE(2026)] = 96692, + [SMALL_STATE(2027)] = 96728, + [SMALL_STATE(2028)] = 96764, + [SMALL_STATE(2029)] = 96802, + [SMALL_STATE(2030)] = 96838, + [SMALL_STATE(2031)] = 96870, + [SMALL_STATE(2032)] = 96906, + [SMALL_STATE(2033)] = 96934, + [SMALL_STATE(2034)] = 96964, + [SMALL_STATE(2035)] = 96988, + [SMALL_STATE(2036)] = 97012, + [SMALL_STATE(2037)] = 97036, + [SMALL_STATE(2038)] = 97072, + [SMALL_STATE(2039)] = 97107, + [SMALL_STATE(2040)] = 97132, + [SMALL_STATE(2041)] = 97165, + [SMALL_STATE(2042)] = 97200, + [SMALL_STATE(2043)] = 97235, + [SMALL_STATE(2044)] = 97268, + [SMALL_STATE(2045)] = 97301, + [SMALL_STATE(2046)] = 97336, + [SMALL_STATE(2047)] = 97371, + [SMALL_STATE(2048)] = 97394, + [SMALL_STATE(2049)] = 97417, + [SMALL_STATE(2050)] = 97450, + [SMALL_STATE(2051)] = 97473, + [SMALL_STATE(2052)] = 97496, + [SMALL_STATE(2053)] = 97527, + [SMALL_STATE(2054)] = 97560, + [SMALL_STATE(2055)] = 97593, + [SMALL_STATE(2056)] = 97628, + [SMALL_STATE(2057)] = 97663, + [SMALL_STATE(2058)] = 97694, + [SMALL_STATE(2059)] = 97717, + [SMALL_STATE(2060)] = 97752, + [SMALL_STATE(2061)] = 97783, + [SMALL_STATE(2062)] = 97818, + [SMALL_STATE(2063)] = 97853, + [SMALL_STATE(2064)] = 97884, + [SMALL_STATE(2065)] = 97919, + [SMALL_STATE(2066)] = 97950, + [SMALL_STATE(2067)] = 97985, + [SMALL_STATE(2068)] = 98008, + [SMALL_STATE(2069)] = 98043, + [SMALL_STATE(2070)] = 98078, + [SMALL_STATE(2071)] = 98111, + [SMALL_STATE(2072)] = 98146, + [SMALL_STATE(2073)] = 98181, + [SMALL_STATE(2074)] = 98216, + [SMALL_STATE(2075)] = 98245, + [SMALL_STATE(2076)] = 98280, + [SMALL_STATE(2077)] = 98313, + [SMALL_STATE(2078)] = 98346, + [SMALL_STATE(2079)] = 98369, + [SMALL_STATE(2080)] = 98404, + [SMALL_STATE(2081)] = 98439, + [SMALL_STATE(2082)] = 98474, + [SMALL_STATE(2083)] = 98509, + [SMALL_STATE(2084)] = 98544, + [SMALL_STATE(2085)] = 98569, + [SMALL_STATE(2086)] = 98594, + [SMALL_STATE(2087)] = 98625, + [SMALL_STATE(2088)] = 98660, + [SMALL_STATE(2089)] = 98693, + [SMALL_STATE(2090)] = 98726, + [SMALL_STATE(2091)] = 98761, + [SMALL_STATE(2092)] = 98796, + [SMALL_STATE(2093)] = 98831, + [SMALL_STATE(2094)] = 98864, + [SMALL_STATE(2095)] = 98899, + [SMALL_STATE(2096)] = 98934, + [SMALL_STATE(2097)] = 98965, + [SMALL_STATE(2098)] = 99000, + [SMALL_STATE(2099)] = 99030, + [SMALL_STATE(2100)] = 99062, + [SMALL_STATE(2101)] = 99094, + [SMALL_STATE(2102)] = 99126, + [SMALL_STATE(2103)] = 99156, + [SMALL_STATE(2104)] = 99186, + [SMALL_STATE(2105)] = 99218, + [SMALL_STATE(2106)] = 99248, + [SMALL_STATE(2107)] = 99278, + [SMALL_STATE(2108)] = 99308, + [SMALL_STATE(2109)] = 99338, + [SMALL_STATE(2110)] = 99368, + [SMALL_STATE(2111)] = 99400, + [SMALL_STATE(2112)] = 99430, + [SMALL_STATE(2113)] = 99460, + [SMALL_STATE(2114)] = 99490, + [SMALL_STATE(2115)] = 99520, + [SMALL_STATE(2116)] = 99550, + [SMALL_STATE(2117)] = 99580, + [SMALL_STATE(2118)] = 99610, + [SMALL_STATE(2119)] = 99640, + [SMALL_STATE(2120)] = 99670, + [SMALL_STATE(2121)] = 99702, + [SMALL_STATE(2122)] = 99732, + [SMALL_STATE(2123)] = 99764, + [SMALL_STATE(2124)] = 99796, + [SMALL_STATE(2125)] = 99828, + [SMALL_STATE(2126)] = 99860, + [SMALL_STATE(2127)] = 99890, + [SMALL_STATE(2128)] = 99920, + [SMALL_STATE(2129)] = 99952, + [SMALL_STATE(2130)] = 99982, + [SMALL_STATE(2131)] = 100004, + [SMALL_STATE(2132)] = 100036, + [SMALL_STATE(2133)] = 100068, + [SMALL_STATE(2134)] = 100100, + [SMALL_STATE(2135)] = 100130, + [SMALL_STATE(2136)] = 100162, + [SMALL_STATE(2137)] = 100192, + [SMALL_STATE(2138)] = 100224, + [SMALL_STATE(2139)] = 100246, + [SMALL_STATE(2140)] = 100278, + [SMALL_STATE(2141)] = 100310, + [SMALL_STATE(2142)] = 100342, + [SMALL_STATE(2143)] = 100372, + [SMALL_STATE(2144)] = 100404, + [SMALL_STATE(2145)] = 100436, + [SMALL_STATE(2146)] = 100468, + [SMALL_STATE(2147)] = 100500, + [SMALL_STATE(2148)] = 100530, + [SMALL_STATE(2149)] = 100560, + [SMALL_STATE(2150)] = 100588, + [SMALL_STATE(2151)] = 100618, + [SMALL_STATE(2152)] = 100650, + [SMALL_STATE(2153)] = 100682, + [SMALL_STATE(2154)] = 100712, + [SMALL_STATE(2155)] = 100744, + [SMALL_STATE(2156)] = 100776, + [SMALL_STATE(2157)] = 100808, + [SMALL_STATE(2158)] = 100840, + [SMALL_STATE(2159)] = 100870, + [SMALL_STATE(2160)] = 100902, + [SMALL_STATE(2161)] = 100932, + [SMALL_STATE(2162)] = 100954, + [SMALL_STATE(2163)] = 100984, + [SMALL_STATE(2164)] = 101016, + [SMALL_STATE(2165)] = 101048, + [SMALL_STATE(2166)] = 101078, + [SMALL_STATE(2167)] = 101108, + [SMALL_STATE(2168)] = 101140, + [SMALL_STATE(2169)] = 101170, + [SMALL_STATE(2170)] = 101200, + [SMALL_STATE(2171)] = 101232, + [SMALL_STATE(2172)] = 101264, + [SMALL_STATE(2173)] = 101292, + [SMALL_STATE(2174)] = 101324, + [SMALL_STATE(2175)] = 101354, + [SMALL_STATE(2176)] = 101386, + [SMALL_STATE(2177)] = 101418, + [SMALL_STATE(2178)] = 101448, + [SMALL_STATE(2179)] = 101480, + [SMALL_STATE(2180)] = 101512, + [SMALL_STATE(2181)] = 101538, + [SMALL_STATE(2182)] = 101562, + [SMALL_STATE(2183)] = 101594, + [SMALL_STATE(2184)] = 101626, + [SMALL_STATE(2185)] = 101658, + [SMALL_STATE(2186)] = 101690, + [SMALL_STATE(2187)] = 101720, + [SMALL_STATE(2188)] = 101752, + [SMALL_STATE(2189)] = 101784, + [SMALL_STATE(2190)] = 101816, + [SMALL_STATE(2191)] = 101838, + [SMALL_STATE(2192)] = 101870, + [SMALL_STATE(2193)] = 101902, + [SMALL_STATE(2194)] = 101934, + [SMALL_STATE(2195)] = 101966, + [SMALL_STATE(2196)] = 101998, + [SMALL_STATE(2197)] = 102030, + [SMALL_STATE(2198)] = 102052, + [SMALL_STATE(2199)] = 102084, + [SMALL_STATE(2200)] = 102116, + [SMALL_STATE(2201)] = 102138, + [SMALL_STATE(2202)] = 102170, + [SMALL_STATE(2203)] = 102202, + [SMALL_STATE(2204)] = 102230, + [SMALL_STATE(2205)] = 102262, + [SMALL_STATE(2206)] = 102292, + [SMALL_STATE(2207)] = 102318, + [SMALL_STATE(2208)] = 102350, + [SMALL_STATE(2209)] = 102378, + [SMALL_STATE(2210)] = 102410, + [SMALL_STATE(2211)] = 102442, + [SMALL_STATE(2212)] = 102470, + [SMALL_STATE(2213)] = 102500, + [SMALL_STATE(2214)] = 102530, + [SMALL_STATE(2215)] = 102560, + [SMALL_STATE(2216)] = 102592, + [SMALL_STATE(2217)] = 102624, + [SMALL_STATE(2218)] = 102654, + [SMALL_STATE(2219)] = 102676, + [SMALL_STATE(2220)] = 102708, + [SMALL_STATE(2221)] = 102738, + [SMALL_STATE(2222)] = 102768, + [SMALL_STATE(2223)] = 102795, + [SMALL_STATE(2224)] = 102824, + [SMALL_STATE(2225)] = 102849, + [SMALL_STATE(2226)] = 102874, + [SMALL_STATE(2227)] = 102903, + [SMALL_STATE(2228)] = 102924, + [SMALL_STATE(2229)] = 102953, + [SMALL_STATE(2230)] = 102982, + [SMALL_STATE(2231)] = 103011, + [SMALL_STATE(2232)] = 103040, + [SMALL_STATE(2233)] = 103067, + [SMALL_STATE(2234)] = 103096, + [SMALL_STATE(2235)] = 103121, + [SMALL_STATE(2236)] = 103146, + [SMALL_STATE(2237)] = 103175, + [SMALL_STATE(2238)] = 103200, + [SMALL_STATE(2239)] = 103225, + [SMALL_STATE(2240)] = 103254, + [SMALL_STATE(2241)] = 103283, + [SMALL_STATE(2242)] = 103312, + [SMALL_STATE(2243)] = 103341, + [SMALL_STATE(2244)] = 103370, + [SMALL_STATE(2245)] = 103399, + [SMALL_STATE(2246)] = 103428, + [SMALL_STATE(2247)] = 103457, + [SMALL_STATE(2248)] = 103486, + [SMALL_STATE(2249)] = 103515, + [SMALL_STATE(2250)] = 103544, + [SMALL_STATE(2251)] = 103573, + [SMALL_STATE(2252)] = 103596, + [SMALL_STATE(2253)] = 103625, + [SMALL_STATE(2254)] = 103652, + [SMALL_STATE(2255)] = 103681, + [SMALL_STATE(2256)] = 103708, + [SMALL_STATE(2257)] = 103737, + [SMALL_STATE(2258)] = 103762, + [SMALL_STATE(2259)] = 103787, + [SMALL_STATE(2260)] = 103816, + [SMALL_STATE(2261)] = 103845, + [SMALL_STATE(2262)] = 103874, + [SMALL_STATE(2263)] = 103895, + [SMALL_STATE(2264)] = 103924, + [SMALL_STATE(2265)] = 103949, + [SMALL_STATE(2266)] = 103976, + [SMALL_STATE(2267)] = 104005, + [SMALL_STATE(2268)] = 104030, + [SMALL_STATE(2269)] = 104059, + [SMALL_STATE(2270)] = 104084, + [SMALL_STATE(2271)] = 104113, + [SMALL_STATE(2272)] = 104142, + [SMALL_STATE(2273)] = 104167, + [SMALL_STATE(2274)] = 104192, + [SMALL_STATE(2275)] = 104217, + [SMALL_STATE(2276)] = 104246, + [SMALL_STATE(2277)] = 104271, + [SMALL_STATE(2278)] = 104296, + [SMALL_STATE(2279)] = 104325, + [SMALL_STATE(2280)] = 104352, + [SMALL_STATE(2281)] = 104381, + [SMALL_STATE(2282)] = 104410, + [SMALL_STATE(2283)] = 104439, + [SMALL_STATE(2284)] = 104464, + [SMALL_STATE(2285)] = 104493, + [SMALL_STATE(2286)] = 104522, + [SMALL_STATE(2287)] = 104551, + [SMALL_STATE(2288)] = 104580, + [SMALL_STATE(2289)] = 104609, + [SMALL_STATE(2290)] = 104638, + [SMALL_STATE(2291)] = 104667, + [SMALL_STATE(2292)] = 104694, + [SMALL_STATE(2293)] = 104723, + [SMALL_STATE(2294)] = 104752, + [SMALL_STATE(2295)] = 104779, + [SMALL_STATE(2296)] = 104808, + [SMALL_STATE(2297)] = 104837, + [SMALL_STATE(2298)] = 104866, + [SMALL_STATE(2299)] = 104891, + [SMALL_STATE(2300)] = 104920, + [SMALL_STATE(2301)] = 104949, + [SMALL_STATE(2302)] = 104974, + [SMALL_STATE(2303)] = 104995, + [SMALL_STATE(2304)] = 105024, + [SMALL_STATE(2305)] = 105053, + [SMALL_STATE(2306)] = 105082, + [SMALL_STATE(2307)] = 105105, + [SMALL_STATE(2308)] = 105130, + [SMALL_STATE(2309)] = 105159, + [SMALL_STATE(2310)] = 105188, + [SMALL_STATE(2311)] = 105217, + [SMALL_STATE(2312)] = 105240, + [SMALL_STATE(2313)] = 105269, + [SMALL_STATE(2314)] = 105294, + [SMALL_STATE(2315)] = 105319, + [SMALL_STATE(2316)] = 105346, + [SMALL_STATE(2317)] = 105371, + [SMALL_STATE(2318)] = 105400, + [SMALL_STATE(2319)] = 105429, + [SMALL_STATE(2320)] = 105458, + [SMALL_STATE(2321)] = 105487, + [SMALL_STATE(2322)] = 105516, + [SMALL_STATE(2323)] = 105545, + [SMALL_STATE(2324)] = 105570, + [SMALL_STATE(2325)] = 105599, + [SMALL_STATE(2326)] = 105624, + [SMALL_STATE(2327)] = 105653, + [SMALL_STATE(2328)] = 105682, + [SMALL_STATE(2329)] = 105711, + [SMALL_STATE(2330)] = 105740, + [SMALL_STATE(2331)] = 105765, + [SMALL_STATE(2332)] = 105794, + [SMALL_STATE(2333)] = 105823, + [SMALL_STATE(2334)] = 105852, + [SMALL_STATE(2335)] = 105877, + [SMALL_STATE(2336)] = 105906, + [SMALL_STATE(2337)] = 105935, + [SMALL_STATE(2338)] = 105964, + [SMALL_STATE(2339)] = 105993, + [SMALL_STATE(2340)] = 106022, + [SMALL_STATE(2341)] = 106051, + [SMALL_STATE(2342)] = 106080, + [SMALL_STATE(2343)] = 106105, + [SMALL_STATE(2344)] = 106134, + [SMALL_STATE(2345)] = 106163, + [SMALL_STATE(2346)] = 106192, + [SMALL_STATE(2347)] = 106221, + [SMALL_STATE(2348)] = 106250, + [SMALL_STATE(2349)] = 106279, + [SMALL_STATE(2350)] = 106304, + [SMALL_STATE(2351)] = 106333, + [SMALL_STATE(2352)] = 106362, + [SMALL_STATE(2353)] = 106391, + [SMALL_STATE(2354)] = 106416, + [SMALL_STATE(2355)] = 106445, + [SMALL_STATE(2356)] = 106474, + [SMALL_STATE(2357)] = 106499, + [SMALL_STATE(2358)] = 106525, + [SMALL_STATE(2359)] = 106551, + [SMALL_STATE(2360)] = 106573, + [SMALL_STATE(2361)] = 106597, + [SMALL_STATE(2362)] = 106623, + [SMALL_STATE(2363)] = 106643, + [SMALL_STATE(2364)] = 106669, + [SMALL_STATE(2365)] = 106689, + [SMALL_STATE(2366)] = 106711, + [SMALL_STATE(2367)] = 106733, + [SMALL_STATE(2368)] = 106759, + [SMALL_STATE(2369)] = 106785, + [SMALL_STATE(2370)] = 106809, + [SMALL_STATE(2371)] = 106831, + [SMALL_STATE(2372)] = 106851, + [SMALL_STATE(2373)] = 106877, + [SMALL_STATE(2374)] = 106899, + [SMALL_STATE(2375)] = 106921, + [SMALL_STATE(2376)] = 106943, + [SMALL_STATE(2377)] = 106965, + [SMALL_STATE(2378)] = 106991, + [SMALL_STATE(2379)] = 107011, + [SMALL_STATE(2380)] = 107033, + [SMALL_STATE(2381)] = 107055, + [SMALL_STATE(2382)] = 107079, + [SMALL_STATE(2383)] = 107101, + [SMALL_STATE(2384)] = 107123, + [SMALL_STATE(2385)] = 107149, + [SMALL_STATE(2386)] = 107171, + [SMALL_STATE(2387)] = 107193, + [SMALL_STATE(2388)] = 107215, + [SMALL_STATE(2389)] = 107237, + [SMALL_STATE(2390)] = 107263, + [SMALL_STATE(2391)] = 107285, + [SMALL_STATE(2392)] = 107311, + [SMALL_STATE(2393)] = 107333, + [SMALL_STATE(2394)] = 107357, + [SMALL_STATE(2395)] = 107383, + [SMALL_STATE(2396)] = 107403, + [SMALL_STATE(2397)] = 107423, + [SMALL_STATE(2398)] = 107445, + [SMALL_STATE(2399)] = 107467, + [SMALL_STATE(2400)] = 107489, + [SMALL_STATE(2401)] = 107511, + [SMALL_STATE(2402)] = 107531, + [SMALL_STATE(2403)] = 107557, + [SMALL_STATE(2404)] = 107577, + [SMALL_STATE(2405)] = 107597, + [SMALL_STATE(2406)] = 107623, + [SMALL_STATE(2407)] = 107643, + [SMALL_STATE(2408)] = 107665, + [SMALL_STATE(2409)] = 107691, + [SMALL_STATE(2410)] = 107717, + [SMALL_STATE(2411)] = 107741, + [SMALL_STATE(2412)] = 107763, + [SMALL_STATE(2413)] = 107785, + [SMALL_STATE(2414)] = 107809, + [SMALL_STATE(2415)] = 107835, + [SMALL_STATE(2416)] = 107861, + [SMALL_STATE(2417)] = 107885, + [SMALL_STATE(2418)] = 107907, + [SMALL_STATE(2419)] = 107931, + [SMALL_STATE(2420)] = 107951, + [SMALL_STATE(2421)] = 107977, + [SMALL_STATE(2422)] = 108003, + [SMALL_STATE(2423)] = 108023, + [SMALL_STATE(2424)] = 108043, + [SMALL_STATE(2425)] = 108069, + [SMALL_STATE(2426)] = 108095, + [SMALL_STATE(2427)] = 108121, + [SMALL_STATE(2428)] = 108141, + [SMALL_STATE(2429)] = 108163, + [SMALL_STATE(2430)] = 108185, + [SMALL_STATE(2431)] = 108209, + [SMALL_STATE(2432)] = 108233, + [SMALL_STATE(2433)] = 108259, + [SMALL_STATE(2434)] = 108281, + [SMALL_STATE(2435)] = 108303, + [SMALL_STATE(2436)] = 108327, + [SMALL_STATE(2437)] = 108353, + [SMALL_STATE(2438)] = 108377, + [SMALL_STATE(2439)] = 108401, + [SMALL_STATE(2440)] = 108423, + [SMALL_STATE(2441)] = 108447, + [SMALL_STATE(2442)] = 108471, + [SMALL_STATE(2443)] = 108491, + [SMALL_STATE(2444)] = 108511, + [SMALL_STATE(2445)] = 108531, + [SMALL_STATE(2446)] = 108551, + [SMALL_STATE(2447)] = 108571, + [SMALL_STATE(2448)] = 108591, + [SMALL_STATE(2449)] = 108611, + [SMALL_STATE(2450)] = 108635, + [SMALL_STATE(2451)] = 108659, + [SMALL_STATE(2452)] = 108683, + [SMALL_STATE(2453)] = 108707, + [SMALL_STATE(2454)] = 108731, + [SMALL_STATE(2455)] = 108751, + [SMALL_STATE(2456)] = 108775, + [SMALL_STATE(2457)] = 108799, + [SMALL_STATE(2458)] = 108823, + [SMALL_STATE(2459)] = 108847, + [SMALL_STATE(2460)] = 108871, + [SMALL_STATE(2461)] = 108895, + [SMALL_STATE(2462)] = 108921, + [SMALL_STATE(2463)] = 108941, + [SMALL_STATE(2464)] = 108961, + [SMALL_STATE(2465)] = 108983, + [SMALL_STATE(2466)] = 109007, + [SMALL_STATE(2467)] = 109029, + [SMALL_STATE(2468)] = 109055, + [SMALL_STATE(2469)] = 109075, + [SMALL_STATE(2470)] = 109101, + [SMALL_STATE(2471)] = 109125, + [SMALL_STATE(2472)] = 109149, + [SMALL_STATE(2473)] = 109173, + [SMALL_STATE(2474)] = 109197, + [SMALL_STATE(2475)] = 109221, + [SMALL_STATE(2476)] = 109245, + [SMALL_STATE(2477)] = 109271, + [SMALL_STATE(2478)] = 109293, + [SMALL_STATE(2479)] = 109315, + [SMALL_STATE(2480)] = 109337, + [SMALL_STATE(2481)] = 109359, + [SMALL_STATE(2482)] = 109385, + [SMALL_STATE(2483)] = 109405, + [SMALL_STATE(2484)] = 109425, + [SMALL_STATE(2485)] = 109449, + [SMALL_STATE(2486)] = 109471, + [SMALL_STATE(2487)] = 109495, + [SMALL_STATE(2488)] = 109517, + [SMALL_STATE(2489)] = 109541, + [SMALL_STATE(2490)] = 109565, + [SMALL_STATE(2491)] = 109589, + [SMALL_STATE(2492)] = 109613, + [SMALL_STATE(2493)] = 109635, + [SMALL_STATE(2494)] = 109661, + [SMALL_STATE(2495)] = 109687, + [SMALL_STATE(2496)] = 109710, + [SMALL_STATE(2497)] = 109733, + [SMALL_STATE(2498)] = 109752, + [SMALL_STATE(2499)] = 109771, + [SMALL_STATE(2500)] = 109790, + [SMALL_STATE(2501)] = 109809, + [SMALL_STATE(2502)] = 109832, + [SMALL_STATE(2503)] = 109851, + [SMALL_STATE(2504)] = 109874, + [SMALL_STATE(2505)] = 109893, + [SMALL_STATE(2506)] = 109912, + [SMALL_STATE(2507)] = 109931, + [SMALL_STATE(2508)] = 109950, + [SMALL_STATE(2509)] = 109969, + [SMALL_STATE(2510)] = 109988, + [SMALL_STATE(2511)] = 110007, + [SMALL_STATE(2512)] = 110026, + [SMALL_STATE(2513)] = 110045, + [SMALL_STATE(2514)] = 110066, + [SMALL_STATE(2515)] = 110089, + [SMALL_STATE(2516)] = 110108, + [SMALL_STATE(2517)] = 110131, + [SMALL_STATE(2518)] = 110154, + [SMALL_STATE(2519)] = 110177, + [SMALL_STATE(2520)] = 110196, + [SMALL_STATE(2521)] = 110219, + [SMALL_STATE(2522)] = 110240, + [SMALL_STATE(2523)] = 110259, + [SMALL_STATE(2524)] = 110282, + [SMALL_STATE(2525)] = 110305, + [SMALL_STATE(2526)] = 110326, + [SMALL_STATE(2527)] = 110349, + [SMALL_STATE(2528)] = 110372, + [SMALL_STATE(2529)] = 110395, + [SMALL_STATE(2530)] = 110418, + [SMALL_STATE(2531)] = 110441, + [SMALL_STATE(2532)] = 110462, + [SMALL_STATE(2533)] = 110485, + [SMALL_STATE(2534)] = 110508, + [SMALL_STATE(2535)] = 110531, + [SMALL_STATE(2536)] = 110554, + [SMALL_STATE(2537)] = 110577, + [SMALL_STATE(2538)] = 110600, + [SMALL_STATE(2539)] = 110623, + [SMALL_STATE(2540)] = 110646, + [SMALL_STATE(2541)] = 110669, + [SMALL_STATE(2542)] = 110692, + [SMALL_STATE(2543)] = 110715, + [SMALL_STATE(2544)] = 110738, + [SMALL_STATE(2545)] = 110761, + [SMALL_STATE(2546)] = 110784, + [SMALL_STATE(2547)] = 110807, + [SMALL_STATE(2548)] = 110830, + [SMALL_STATE(2549)] = 110853, + [SMALL_STATE(2550)] = 110872, + [SMALL_STATE(2551)] = 110895, + [SMALL_STATE(2552)] = 110918, + [SMALL_STATE(2553)] = 110941, + [SMALL_STATE(2554)] = 110960, + [SMALL_STATE(2555)] = 110983, + [SMALL_STATE(2556)] = 111006, + [SMALL_STATE(2557)] = 111029, + [SMALL_STATE(2558)] = 111052, + [SMALL_STATE(2559)] = 111075, + [SMALL_STATE(2560)] = 111094, + [SMALL_STATE(2561)] = 111117, + [SMALL_STATE(2562)] = 111140, + [SMALL_STATE(2563)] = 111159, + [SMALL_STATE(2564)] = 111178, + [SMALL_STATE(2565)] = 111201, + [SMALL_STATE(2566)] = 111220, + [SMALL_STATE(2567)] = 111239, + [SMALL_STATE(2568)] = 111258, + [SMALL_STATE(2569)] = 111281, + [SMALL_STATE(2570)] = 111304, + [SMALL_STATE(2571)] = 111327, + [SMALL_STATE(2572)] = 111346, + [SMALL_STATE(2573)] = 111369, + [SMALL_STATE(2574)] = 111392, + [SMALL_STATE(2575)] = 111415, + [SMALL_STATE(2576)] = 111434, + [SMALL_STATE(2577)] = 111457, + [SMALL_STATE(2578)] = 111480, + [SMALL_STATE(2579)] = 111499, + [SMALL_STATE(2580)] = 111520, + [SMALL_STATE(2581)] = 111543, + [SMALL_STATE(2582)] = 111562, + [SMALL_STATE(2583)] = 111581, + [SMALL_STATE(2584)] = 111604, + [SMALL_STATE(2585)] = 111623, + [SMALL_STATE(2586)] = 111642, + [SMALL_STATE(2587)] = 111661, + [SMALL_STATE(2588)] = 111680, + [SMALL_STATE(2589)] = 111699, + [SMALL_STATE(2590)] = 111722, + [SMALL_STATE(2591)] = 111745, + [SMALL_STATE(2592)] = 111768, + [SMALL_STATE(2593)] = 111791, + [SMALL_STATE(2594)] = 111814, + [SMALL_STATE(2595)] = 111837, + [SMALL_STATE(2596)] = 111860, + [SMALL_STATE(2597)] = 111883, + [SMALL_STATE(2598)] = 111906, + [SMALL_STATE(2599)] = 111929, + [SMALL_STATE(2600)] = 111952, + [SMALL_STATE(2601)] = 111971, + [SMALL_STATE(2602)] = 111990, + [SMALL_STATE(2603)] = 112011, + [SMALL_STATE(2604)] = 112030, + [SMALL_STATE(2605)] = 112053, + [SMALL_STATE(2606)] = 112072, + [SMALL_STATE(2607)] = 112091, + [SMALL_STATE(2608)] = 112110, + [SMALL_STATE(2609)] = 112129, + [SMALL_STATE(2610)] = 112148, + [SMALL_STATE(2611)] = 112171, + [SMALL_STATE(2612)] = 112194, + [SMALL_STATE(2613)] = 112217, + [SMALL_STATE(2614)] = 112236, + [SMALL_STATE(2615)] = 112259, + [SMALL_STATE(2616)] = 112278, + [SMALL_STATE(2617)] = 112301, + [SMALL_STATE(2618)] = 112324, + [SMALL_STATE(2619)] = 112347, + [SMALL_STATE(2620)] = 112370, + [SMALL_STATE(2621)] = 112393, + [SMALL_STATE(2622)] = 112416, + [SMALL_STATE(2623)] = 112439, + [SMALL_STATE(2624)] = 112462, + [SMALL_STATE(2625)] = 112485, + [SMALL_STATE(2626)] = 112508, + [SMALL_STATE(2627)] = 112531, + [SMALL_STATE(2628)] = 112550, + [SMALL_STATE(2629)] = 112569, + [SMALL_STATE(2630)] = 112588, + [SMALL_STATE(2631)] = 112607, + [SMALL_STATE(2632)] = 112626, + [SMALL_STATE(2633)] = 112649, + [SMALL_STATE(2634)] = 112672, + [SMALL_STATE(2635)] = 112695, + [SMALL_STATE(2636)] = 112718, + [SMALL_STATE(2637)] = 112741, + [SMALL_STATE(2638)] = 112764, + [SMALL_STATE(2639)] = 112785, + [SMALL_STATE(2640)] = 112808, + [SMALL_STATE(2641)] = 112831, + [SMALL_STATE(2642)] = 112854, + [SMALL_STATE(2643)] = 112877, + [SMALL_STATE(2644)] = 112900, + [SMALL_STATE(2645)] = 112923, + [SMALL_STATE(2646)] = 112946, + [SMALL_STATE(2647)] = 112969, + [SMALL_STATE(2648)] = 112992, + [SMALL_STATE(2649)] = 113015, + [SMALL_STATE(2650)] = 113038, + [SMALL_STATE(2651)] = 113061, + [SMALL_STATE(2652)] = 113084, + [SMALL_STATE(2653)] = 113107, + [SMALL_STATE(2654)] = 113130, + [SMALL_STATE(2655)] = 113153, + [SMALL_STATE(2656)] = 113176, + [SMALL_STATE(2657)] = 113199, + [SMALL_STATE(2658)] = 113220, + [SMALL_STATE(2659)] = 113243, + [SMALL_STATE(2660)] = 113266, + [SMALL_STATE(2661)] = 113289, + [SMALL_STATE(2662)] = 113312, + [SMALL_STATE(2663)] = 113335, + [SMALL_STATE(2664)] = 113358, + [SMALL_STATE(2665)] = 113381, + [SMALL_STATE(2666)] = 113404, + [SMALL_STATE(2667)] = 113423, + [SMALL_STATE(2668)] = 113446, + [SMALL_STATE(2669)] = 113469, + [SMALL_STATE(2670)] = 113492, + [SMALL_STATE(2671)] = 113515, + [SMALL_STATE(2672)] = 113538, + [SMALL_STATE(2673)] = 113561, + [SMALL_STATE(2674)] = 113584, + [SMALL_STATE(2675)] = 113607, + [SMALL_STATE(2676)] = 113630, + [SMALL_STATE(2677)] = 113653, + [SMALL_STATE(2678)] = 113676, + [SMALL_STATE(2679)] = 113699, + [SMALL_STATE(2680)] = 113722, + [SMALL_STATE(2681)] = 113745, + [SMALL_STATE(2682)] = 113768, + [SMALL_STATE(2683)] = 113791, + [SMALL_STATE(2684)] = 113814, + [SMALL_STATE(2685)] = 113837, + [SMALL_STATE(2686)] = 113858, + [SMALL_STATE(2687)] = 113881, + [SMALL_STATE(2688)] = 113904, + [SMALL_STATE(2689)] = 113923, + [SMALL_STATE(2690)] = 113946, + [SMALL_STATE(2691)] = 113969, + [SMALL_STATE(2692)] = 113992, + [SMALL_STATE(2693)] = 114011, + [SMALL_STATE(2694)] = 114034, + [SMALL_STATE(2695)] = 114057, + [SMALL_STATE(2696)] = 114076, + [SMALL_STATE(2697)] = 114099, + [SMALL_STATE(2698)] = 114122, + [SMALL_STATE(2699)] = 114141, + [SMALL_STATE(2700)] = 114164, + [SMALL_STATE(2701)] = 114183, + [SMALL_STATE(2702)] = 114206, + [SMALL_STATE(2703)] = 114229, + [SMALL_STATE(2704)] = 114248, + [SMALL_STATE(2705)] = 114271, + [SMALL_STATE(2706)] = 114294, + [SMALL_STATE(2707)] = 114317, + [SMALL_STATE(2708)] = 114340, + [SMALL_STATE(2709)] = 114363, + [SMALL_STATE(2710)] = 114386, + [SMALL_STATE(2711)] = 114409, + [SMALL_STATE(2712)] = 114432, + [SMALL_STATE(2713)] = 114455, + [SMALL_STATE(2714)] = 114478, + [SMALL_STATE(2715)] = 114501, + [SMALL_STATE(2716)] = 114524, + [SMALL_STATE(2717)] = 114547, + [SMALL_STATE(2718)] = 114570, + [SMALL_STATE(2719)] = 114593, + [SMALL_STATE(2720)] = 114616, + [SMALL_STATE(2721)] = 114639, + [SMALL_STATE(2722)] = 114662, + [SMALL_STATE(2723)] = 114685, + [SMALL_STATE(2724)] = 114708, + [SMALL_STATE(2725)] = 114731, + [SMALL_STATE(2726)] = 114754, + [SMALL_STATE(2727)] = 114777, + [SMALL_STATE(2728)] = 114800, + [SMALL_STATE(2729)] = 114823, + [SMALL_STATE(2730)] = 114846, + [SMALL_STATE(2731)] = 114869, + [SMALL_STATE(2732)] = 114892, + [SMALL_STATE(2733)] = 114915, + [SMALL_STATE(2734)] = 114934, + [SMALL_STATE(2735)] = 114957, + [SMALL_STATE(2736)] = 114980, + [SMALL_STATE(2737)] = 115003, + [SMALL_STATE(2738)] = 115026, + [SMALL_STATE(2739)] = 115045, + [SMALL_STATE(2740)] = 115068, + [SMALL_STATE(2741)] = 115087, + [SMALL_STATE(2742)] = 115110, + [SMALL_STATE(2743)] = 115133, + [SMALL_STATE(2744)] = 115156, + [SMALL_STATE(2745)] = 115179, + [SMALL_STATE(2746)] = 115202, + [SMALL_STATE(2747)] = 115221, + [SMALL_STATE(2748)] = 115244, + [SMALL_STATE(2749)] = 115263, + [SMALL_STATE(2750)] = 115286, + [SMALL_STATE(2751)] = 115309, + [SMALL_STATE(2752)] = 115332, + [SMALL_STATE(2753)] = 115355, + [SMALL_STATE(2754)] = 115378, + [SMALL_STATE(2755)] = 115401, + [SMALL_STATE(2756)] = 115424, + [SMALL_STATE(2757)] = 115447, + [SMALL_STATE(2758)] = 115470, + [SMALL_STATE(2759)] = 115491, + [SMALL_STATE(2760)] = 115514, + [SMALL_STATE(2761)] = 115537, + [SMALL_STATE(2762)] = 115560, + [SMALL_STATE(2763)] = 115583, + [SMALL_STATE(2764)] = 115606, + [SMALL_STATE(2765)] = 115625, + [SMALL_STATE(2766)] = 115644, + [SMALL_STATE(2767)] = 115667, + [SMALL_STATE(2768)] = 115690, + [SMALL_STATE(2769)] = 115713, + [SMALL_STATE(2770)] = 115736, + [SMALL_STATE(2771)] = 115759, + [SMALL_STATE(2772)] = 115782, + [SMALL_STATE(2773)] = 115805, + [SMALL_STATE(2774)] = 115828, + [SMALL_STATE(2775)] = 115849, + [SMALL_STATE(2776)] = 115872, + [SMALL_STATE(2777)] = 115895, + [SMALL_STATE(2778)] = 115918, + [SMALL_STATE(2779)] = 115941, + [SMALL_STATE(2780)] = 115964, + [SMALL_STATE(2781)] = 115987, + [SMALL_STATE(2782)] = 116010, + [SMALL_STATE(2783)] = 116033, + [SMALL_STATE(2784)] = 116056, + [SMALL_STATE(2785)] = 116075, + [SMALL_STATE(2786)] = 116094, + [SMALL_STATE(2787)] = 116117, + [SMALL_STATE(2788)] = 116140, + [SMALL_STATE(2789)] = 116163, + [SMALL_STATE(2790)] = 116186, + [SMALL_STATE(2791)] = 116207, + [SMALL_STATE(2792)] = 116230, + [SMALL_STATE(2793)] = 116253, + [SMALL_STATE(2794)] = 116276, + [SMALL_STATE(2795)] = 116299, + [SMALL_STATE(2796)] = 116322, + [SMALL_STATE(2797)] = 116345, + [SMALL_STATE(2798)] = 116368, + [SMALL_STATE(2799)] = 116391, + [SMALL_STATE(2800)] = 116414, + [SMALL_STATE(2801)] = 116437, + [SMALL_STATE(2802)] = 116460, + [SMALL_STATE(2803)] = 116483, + [SMALL_STATE(2804)] = 116506, + [SMALL_STATE(2805)] = 116529, + [SMALL_STATE(2806)] = 116552, + [SMALL_STATE(2807)] = 116575, + [SMALL_STATE(2808)] = 116598, + [SMALL_STATE(2809)] = 116621, + [SMALL_STATE(2810)] = 116640, + [SMALL_STATE(2811)] = 116663, + [SMALL_STATE(2812)] = 116682, + [SMALL_STATE(2813)] = 116701, + [SMALL_STATE(2814)] = 116724, + [SMALL_STATE(2815)] = 116747, + [SMALL_STATE(2816)] = 116770, + [SMALL_STATE(2817)] = 116793, + [SMALL_STATE(2818)] = 116816, + [SMALL_STATE(2819)] = 116839, + [SMALL_STATE(2820)] = 116862, + [SMALL_STATE(2821)] = 116885, + [SMALL_STATE(2822)] = 116908, + [SMALL_STATE(2823)] = 116927, + [SMALL_STATE(2824)] = 116946, + [SMALL_STATE(2825)] = 116969, + [SMALL_STATE(2826)] = 116992, + [SMALL_STATE(2827)] = 117015, + [SMALL_STATE(2828)] = 117038, + [SMALL_STATE(2829)] = 117061, + [SMALL_STATE(2830)] = 117084, + [SMALL_STATE(2831)] = 117107, + [SMALL_STATE(2832)] = 117130, + [SMALL_STATE(2833)] = 117153, + [SMALL_STATE(2834)] = 117176, + [SMALL_STATE(2835)] = 117199, + [SMALL_STATE(2836)] = 117222, + [SMALL_STATE(2837)] = 117241, + [SMALL_STATE(2838)] = 117260, + [SMALL_STATE(2839)] = 117283, + [SMALL_STATE(2840)] = 117306, + [SMALL_STATE(2841)] = 117329, + [SMALL_STATE(2842)] = 117352, + [SMALL_STATE(2843)] = 117375, + [SMALL_STATE(2844)] = 117398, + [SMALL_STATE(2845)] = 117421, + [SMALL_STATE(2846)] = 117444, + [SMALL_STATE(2847)] = 117467, + [SMALL_STATE(2848)] = 117490, + [SMALL_STATE(2849)] = 117513, + [SMALL_STATE(2850)] = 117536, + [SMALL_STATE(2851)] = 117559, + [SMALL_STATE(2852)] = 117582, + [SMALL_STATE(2853)] = 117605, + [SMALL_STATE(2854)] = 117628, + [SMALL_STATE(2855)] = 117651, + [SMALL_STATE(2856)] = 117674, + [SMALL_STATE(2857)] = 117697, + [SMALL_STATE(2858)] = 117716, + [SMALL_STATE(2859)] = 117739, + [SMALL_STATE(2860)] = 117762, + [SMALL_STATE(2861)] = 117785, + [SMALL_STATE(2862)] = 117804, + [SMALL_STATE(2863)] = 117827, + [SMALL_STATE(2864)] = 117850, + [SMALL_STATE(2865)] = 117873, + [SMALL_STATE(2866)] = 117892, + [SMALL_STATE(2867)] = 117915, + [SMALL_STATE(2868)] = 117938, + [SMALL_STATE(2869)] = 117961, + [SMALL_STATE(2870)] = 117984, + [SMALL_STATE(2871)] = 118007, + [SMALL_STATE(2872)] = 118026, + [SMALL_STATE(2873)] = 118045, + [SMALL_STATE(2874)] = 118064, + [SMALL_STATE(2875)] = 118083, + [SMALL_STATE(2876)] = 118102, + [SMALL_STATE(2877)] = 118125, + [SMALL_STATE(2878)] = 118148, + [SMALL_STATE(2879)] = 118171, + [SMALL_STATE(2880)] = 118190, + [SMALL_STATE(2881)] = 118213, + [SMALL_STATE(2882)] = 118232, + [SMALL_STATE(2883)] = 118251, + [SMALL_STATE(2884)] = 118274, + [SMALL_STATE(2885)] = 118297, + [SMALL_STATE(2886)] = 118320, + [SMALL_STATE(2887)] = 118343, + [SMALL_STATE(2888)] = 118362, + [SMALL_STATE(2889)] = 118381, + [SMALL_STATE(2890)] = 118404, + [SMALL_STATE(2891)] = 118423, + [SMALL_STATE(2892)] = 118442, + [SMALL_STATE(2893)] = 118461, + [SMALL_STATE(2894)] = 118480, + [SMALL_STATE(2895)] = 118499, + [SMALL_STATE(2896)] = 118518, + [SMALL_STATE(2897)] = 118537, + [SMALL_STATE(2898)] = 118558, + [SMALL_STATE(2899)] = 118581, + [SMALL_STATE(2900)] = 118604, + [SMALL_STATE(2901)] = 118627, + [SMALL_STATE(2902)] = 118650, + [SMALL_STATE(2903)] = 118673, + [SMALL_STATE(2904)] = 118692, + [SMALL_STATE(2905)] = 118711, + [SMALL_STATE(2906)] = 118734, + [SMALL_STATE(2907)] = 118757, + [SMALL_STATE(2908)] = 118776, + [SMALL_STATE(2909)] = 118799, + [SMALL_STATE(2910)] = 118822, + [SMALL_STATE(2911)] = 118841, + [SMALL_STATE(2912)] = 118864, + [SMALL_STATE(2913)] = 118883, + [SMALL_STATE(2914)] = 118906, + [SMALL_STATE(2915)] = 118927, + [SMALL_STATE(2916)] = 118946, + [SMALL_STATE(2917)] = 118969, + [SMALL_STATE(2918)] = 118992, + [SMALL_STATE(2919)] = 119011, + [SMALL_STATE(2920)] = 119030, + [SMALL_STATE(2921)] = 119050, + [SMALL_STATE(2922)] = 119070, + [SMALL_STATE(2923)] = 119090, + [SMALL_STATE(2924)] = 119110, + [SMALL_STATE(2925)] = 119130, + [SMALL_STATE(2926)] = 119150, + [SMALL_STATE(2927)] = 119170, + [SMALL_STATE(2928)] = 119190, + [SMALL_STATE(2929)] = 119210, + [SMALL_STATE(2930)] = 119230, + [SMALL_STATE(2931)] = 119250, + [SMALL_STATE(2932)] = 119270, + [SMALL_STATE(2933)] = 119290, + [SMALL_STATE(2934)] = 119310, + [SMALL_STATE(2935)] = 119330, + [SMALL_STATE(2936)] = 119350, + [SMALL_STATE(2937)] = 119370, + [SMALL_STATE(2938)] = 119390, + [SMALL_STATE(2939)] = 119410, + [SMALL_STATE(2940)] = 119430, + [SMALL_STATE(2941)] = 119448, + [SMALL_STATE(2942)] = 119468, + [SMALL_STATE(2943)] = 119488, + [SMALL_STATE(2944)] = 119508, + [SMALL_STATE(2945)] = 119528, + [SMALL_STATE(2946)] = 119548, + [SMALL_STATE(2947)] = 119568, + [SMALL_STATE(2948)] = 119588, + [SMALL_STATE(2949)] = 119608, + [SMALL_STATE(2950)] = 119628, + [SMALL_STATE(2951)] = 119648, + [SMALL_STATE(2952)] = 119668, + [SMALL_STATE(2953)] = 119688, + [SMALL_STATE(2954)] = 119708, + [SMALL_STATE(2955)] = 119728, + [SMALL_STATE(2956)] = 119748, + [SMALL_STATE(2957)] = 119768, + [SMALL_STATE(2958)] = 119788, + [SMALL_STATE(2959)] = 119806, + [SMALL_STATE(2960)] = 119826, + [SMALL_STATE(2961)] = 119846, + [SMALL_STATE(2962)] = 119866, + [SMALL_STATE(2963)] = 119886, + [SMALL_STATE(2964)] = 119906, + [SMALL_STATE(2965)] = 119926, + [SMALL_STATE(2966)] = 119946, + [SMALL_STATE(2967)] = 119966, + [SMALL_STATE(2968)] = 119986, + [SMALL_STATE(2969)] = 120006, + [SMALL_STATE(2970)] = 120026, + [SMALL_STATE(2971)] = 120046, + [SMALL_STATE(2972)] = 120066, + [SMALL_STATE(2973)] = 120086, + [SMALL_STATE(2974)] = 120106, + [SMALL_STATE(2975)] = 120126, + [SMALL_STATE(2976)] = 120146, + [SMALL_STATE(2977)] = 120166, + [SMALL_STATE(2978)] = 120186, + [SMALL_STATE(2979)] = 120206, + [SMALL_STATE(2980)] = 120226, + [SMALL_STATE(2981)] = 120246, + [SMALL_STATE(2982)] = 120266, + [SMALL_STATE(2983)] = 120286, + [SMALL_STATE(2984)] = 120306, + [SMALL_STATE(2985)] = 120326, + [SMALL_STATE(2986)] = 120346, + [SMALL_STATE(2987)] = 120366, + [SMALL_STATE(2988)] = 120386, + [SMALL_STATE(2989)] = 120406, + [SMALL_STATE(2990)] = 120426, + [SMALL_STATE(2991)] = 120446, + [SMALL_STATE(2992)] = 120466, + [SMALL_STATE(2993)] = 120486, + [SMALL_STATE(2994)] = 120506, + [SMALL_STATE(2995)] = 120526, + [SMALL_STATE(2996)] = 120546, + [SMALL_STATE(2997)] = 120566, + [SMALL_STATE(2998)] = 120586, + [SMALL_STATE(2999)] = 120606, + [SMALL_STATE(3000)] = 120626, + [SMALL_STATE(3001)] = 120646, + [SMALL_STATE(3002)] = 120666, + [SMALL_STATE(3003)] = 120686, + [SMALL_STATE(3004)] = 120706, + [SMALL_STATE(3005)] = 120726, + [SMALL_STATE(3006)] = 120746, + [SMALL_STATE(3007)] = 120766, + [SMALL_STATE(3008)] = 120786, + [SMALL_STATE(3009)] = 120806, + [SMALL_STATE(3010)] = 120826, + [SMALL_STATE(3011)] = 120846, + [SMALL_STATE(3012)] = 120866, + [SMALL_STATE(3013)] = 120886, + [SMALL_STATE(3014)] = 120906, + [SMALL_STATE(3015)] = 120926, + [SMALL_STATE(3016)] = 120946, + [SMALL_STATE(3017)] = 120966, + [SMALL_STATE(3018)] = 120986, + [SMALL_STATE(3019)] = 121006, + [SMALL_STATE(3020)] = 121026, + [SMALL_STATE(3021)] = 121046, + [SMALL_STATE(3022)] = 121066, + [SMALL_STATE(3023)] = 121084, + [SMALL_STATE(3024)] = 121104, + [SMALL_STATE(3025)] = 121124, + [SMALL_STATE(3026)] = 121144, + [SMALL_STATE(3027)] = 121164, + [SMALL_STATE(3028)] = 121184, + [SMALL_STATE(3029)] = 121202, + [SMALL_STATE(3030)] = 121222, + [SMALL_STATE(3031)] = 121242, + [SMALL_STATE(3032)] = 121262, + [SMALL_STATE(3033)] = 121282, + [SMALL_STATE(3034)] = 121302, + [SMALL_STATE(3035)] = 121322, + [SMALL_STATE(3036)] = 121342, + [SMALL_STATE(3037)] = 121362, + [SMALL_STATE(3038)] = 121382, + [SMALL_STATE(3039)] = 121402, + [SMALL_STATE(3040)] = 121422, + [SMALL_STATE(3041)] = 121442, + [SMALL_STATE(3042)] = 121462, + [SMALL_STATE(3043)] = 121482, + [SMALL_STATE(3044)] = 121502, + [SMALL_STATE(3045)] = 121522, + [SMALL_STATE(3046)] = 121540, + [SMALL_STATE(3047)] = 121560, + [SMALL_STATE(3048)] = 121580, + [SMALL_STATE(3049)] = 121600, + [SMALL_STATE(3050)] = 121620, + [SMALL_STATE(3051)] = 121640, + [SMALL_STATE(3052)] = 121660, + [SMALL_STATE(3053)] = 121680, + [SMALL_STATE(3054)] = 121700, + [SMALL_STATE(3055)] = 121720, + [SMALL_STATE(3056)] = 121740, + [SMALL_STATE(3057)] = 121760, + [SMALL_STATE(3058)] = 121778, + [SMALL_STATE(3059)] = 121798, + [SMALL_STATE(3060)] = 121818, + [SMALL_STATE(3061)] = 121838, + [SMALL_STATE(3062)] = 121858, + [SMALL_STATE(3063)] = 121878, + [SMALL_STATE(3064)] = 121898, + [SMALL_STATE(3065)] = 121918, + [SMALL_STATE(3066)] = 121938, + [SMALL_STATE(3067)] = 121958, + [SMALL_STATE(3068)] = 121978, + [SMALL_STATE(3069)] = 121998, + [SMALL_STATE(3070)] = 122018, + [SMALL_STATE(3071)] = 122038, + [SMALL_STATE(3072)] = 122058, + [SMALL_STATE(3073)] = 122078, + [SMALL_STATE(3074)] = 122098, + [SMALL_STATE(3075)] = 122118, + [SMALL_STATE(3076)] = 122136, + [SMALL_STATE(3077)] = 122156, + [SMALL_STATE(3078)] = 122176, + [SMALL_STATE(3079)] = 122196, + [SMALL_STATE(3080)] = 122216, + [SMALL_STATE(3081)] = 122236, + [SMALL_STATE(3082)] = 122256, + [SMALL_STATE(3083)] = 122276, + [SMALL_STATE(3084)] = 122296, + [SMALL_STATE(3085)] = 122316, + [SMALL_STATE(3086)] = 122336, + [SMALL_STATE(3087)] = 122354, + [SMALL_STATE(3088)] = 122374, + [SMALL_STATE(3089)] = 122394, + [SMALL_STATE(3090)] = 122414, + [SMALL_STATE(3091)] = 122434, + [SMALL_STATE(3092)] = 122454, + [SMALL_STATE(3093)] = 122474, + [SMALL_STATE(3094)] = 122494, + [SMALL_STATE(3095)] = 122514, + [SMALL_STATE(3096)] = 122534, + [SMALL_STATE(3097)] = 122552, + [SMALL_STATE(3098)] = 122572, + [SMALL_STATE(3099)] = 122590, + [SMALL_STATE(3100)] = 122610, + [SMALL_STATE(3101)] = 122630, + [SMALL_STATE(3102)] = 122650, + [SMALL_STATE(3103)] = 122670, + [SMALL_STATE(3104)] = 122690, + [SMALL_STATE(3105)] = 122710, + [SMALL_STATE(3106)] = 122730, + [SMALL_STATE(3107)] = 122750, + [SMALL_STATE(3108)] = 122770, + [SMALL_STATE(3109)] = 122790, + [SMALL_STATE(3110)] = 122810, + [SMALL_STATE(3111)] = 122830, + [SMALL_STATE(3112)] = 122850, + [SMALL_STATE(3113)] = 122870, + [SMALL_STATE(3114)] = 122890, + [SMALL_STATE(3115)] = 122910, + [SMALL_STATE(3116)] = 122930, + [SMALL_STATE(3117)] = 122950, + [SMALL_STATE(3118)] = 122970, + [SMALL_STATE(3119)] = 122990, + [SMALL_STATE(3120)] = 123010, + [SMALL_STATE(3121)] = 123030, + [SMALL_STATE(3122)] = 123050, + [SMALL_STATE(3123)] = 123070, + [SMALL_STATE(3124)] = 123090, + [SMALL_STATE(3125)] = 123110, + [SMALL_STATE(3126)] = 123130, + [SMALL_STATE(3127)] = 123150, + [SMALL_STATE(3128)] = 123170, + [SMALL_STATE(3129)] = 123190, + [SMALL_STATE(3130)] = 123210, + [SMALL_STATE(3131)] = 123230, + [SMALL_STATE(3132)] = 123250, + [SMALL_STATE(3133)] = 123270, + [SMALL_STATE(3134)] = 123290, + [SMALL_STATE(3135)] = 123310, + [SMALL_STATE(3136)] = 123330, + [SMALL_STATE(3137)] = 123350, + [SMALL_STATE(3138)] = 123368, + [SMALL_STATE(3139)] = 123388, + [SMALL_STATE(3140)] = 123408, + [SMALL_STATE(3141)] = 123428, + [SMALL_STATE(3142)] = 123448, + [SMALL_STATE(3143)] = 123468, + [SMALL_STATE(3144)] = 123488, + [SMALL_STATE(3145)] = 123508, + [SMALL_STATE(3146)] = 123528, + [SMALL_STATE(3147)] = 123548, + [SMALL_STATE(3148)] = 123568, + [SMALL_STATE(3149)] = 123588, + [SMALL_STATE(3150)] = 123608, + [SMALL_STATE(3151)] = 123628, + [SMALL_STATE(3152)] = 123648, + [SMALL_STATE(3153)] = 123668, + [SMALL_STATE(3154)] = 123688, + [SMALL_STATE(3155)] = 123708, + [SMALL_STATE(3156)] = 123728, + [SMALL_STATE(3157)] = 123746, + [SMALL_STATE(3158)] = 123766, + [SMALL_STATE(3159)] = 123786, + [SMALL_STATE(3160)] = 123806, + [SMALL_STATE(3161)] = 123826, + [SMALL_STATE(3162)] = 123846, + [SMALL_STATE(3163)] = 123866, + [SMALL_STATE(3164)] = 123886, + [SMALL_STATE(3165)] = 123906, + [SMALL_STATE(3166)] = 123926, + [SMALL_STATE(3167)] = 123946, + [SMALL_STATE(3168)] = 123966, + [SMALL_STATE(3169)] = 123984, + [SMALL_STATE(3170)] = 124004, + [SMALL_STATE(3171)] = 124024, + [SMALL_STATE(3172)] = 124044, + [SMALL_STATE(3173)] = 124064, + [SMALL_STATE(3174)] = 124084, + [SMALL_STATE(3175)] = 124104, + [SMALL_STATE(3176)] = 124124, + [SMALL_STATE(3177)] = 124144, + [SMALL_STATE(3178)] = 124164, + [SMALL_STATE(3179)] = 124184, + [SMALL_STATE(3180)] = 124204, + [SMALL_STATE(3181)] = 124224, + [SMALL_STATE(3182)] = 124244, + [SMALL_STATE(3183)] = 124264, + [SMALL_STATE(3184)] = 124284, + [SMALL_STATE(3185)] = 124304, + [SMALL_STATE(3186)] = 124324, + [SMALL_STATE(3187)] = 124344, + [SMALL_STATE(3188)] = 124364, + [SMALL_STATE(3189)] = 124384, + [SMALL_STATE(3190)] = 124404, + [SMALL_STATE(3191)] = 124424, + [SMALL_STATE(3192)] = 124444, + [SMALL_STATE(3193)] = 124464, + [SMALL_STATE(3194)] = 124484, + [SMALL_STATE(3195)] = 124504, + [SMALL_STATE(3196)] = 124524, + [SMALL_STATE(3197)] = 124544, + [SMALL_STATE(3198)] = 124564, + [SMALL_STATE(3199)] = 124584, + [SMALL_STATE(3200)] = 124604, + [SMALL_STATE(3201)] = 124624, + [SMALL_STATE(3202)] = 124644, + [SMALL_STATE(3203)] = 124664, + [SMALL_STATE(3204)] = 124684, + [SMALL_STATE(3205)] = 124702, + [SMALL_STATE(3206)] = 124722, + [SMALL_STATE(3207)] = 124742, + [SMALL_STATE(3208)] = 124762, + [SMALL_STATE(3209)] = 124782, + [SMALL_STATE(3210)] = 124802, + [SMALL_STATE(3211)] = 124822, + [SMALL_STATE(3212)] = 124842, + [SMALL_STATE(3213)] = 124862, + [SMALL_STATE(3214)] = 124882, + [SMALL_STATE(3215)] = 124900, + [SMALL_STATE(3216)] = 124920, + [SMALL_STATE(3217)] = 124940, + [SMALL_STATE(3218)] = 124960, + [SMALL_STATE(3219)] = 124980, + [SMALL_STATE(3220)] = 125000, + [SMALL_STATE(3221)] = 125020, + [SMALL_STATE(3222)] = 125038, + [SMALL_STATE(3223)] = 125058, + [SMALL_STATE(3224)] = 125078, + [SMALL_STATE(3225)] = 125098, + [SMALL_STATE(3226)] = 125118, + [SMALL_STATE(3227)] = 125136, + [SMALL_STATE(3228)] = 125156, + [SMALL_STATE(3229)] = 125176, + [SMALL_STATE(3230)] = 125194, + [SMALL_STATE(3231)] = 125214, + [SMALL_STATE(3232)] = 125234, + [SMALL_STATE(3233)] = 125254, + [SMALL_STATE(3234)] = 125274, + [SMALL_STATE(3235)] = 125294, + [SMALL_STATE(3236)] = 125314, + [SMALL_STATE(3237)] = 125334, + [SMALL_STATE(3238)] = 125354, + [SMALL_STATE(3239)] = 125374, + [SMALL_STATE(3240)] = 125394, + [SMALL_STATE(3241)] = 125414, + [SMALL_STATE(3242)] = 125434, + [SMALL_STATE(3243)] = 125454, + [SMALL_STATE(3244)] = 125474, + [SMALL_STATE(3245)] = 125492, + [SMALL_STATE(3246)] = 125512, + [SMALL_STATE(3247)] = 125530, + [SMALL_STATE(3248)] = 125550, + [SMALL_STATE(3249)] = 125570, + [SMALL_STATE(3250)] = 125590, + [SMALL_STATE(3251)] = 125610, + [SMALL_STATE(3252)] = 125630, + [SMALL_STATE(3253)] = 125650, + [SMALL_STATE(3254)] = 125670, + [SMALL_STATE(3255)] = 125690, + [SMALL_STATE(3256)] = 125710, + [SMALL_STATE(3257)] = 125730, + [SMALL_STATE(3258)] = 125750, + [SMALL_STATE(3259)] = 125770, + [SMALL_STATE(3260)] = 125790, + [SMALL_STATE(3261)] = 125810, + [SMALL_STATE(3262)] = 125830, + [SMALL_STATE(3263)] = 125850, + [SMALL_STATE(3264)] = 125870, + [SMALL_STATE(3265)] = 125890, + [SMALL_STATE(3266)] = 125908, + [SMALL_STATE(3267)] = 125928, + [SMALL_STATE(3268)] = 125948, + [SMALL_STATE(3269)] = 125968, + [SMALL_STATE(3270)] = 125988, + [SMALL_STATE(3271)] = 126006, + [SMALL_STATE(3272)] = 126024, + [SMALL_STATE(3273)] = 126044, + [SMALL_STATE(3274)] = 126064, + [SMALL_STATE(3275)] = 126084, + [SMALL_STATE(3276)] = 126104, + [SMALL_STATE(3277)] = 126124, + [SMALL_STATE(3278)] = 126144, + [SMALL_STATE(3279)] = 126162, + [SMALL_STATE(3280)] = 126182, + [SMALL_STATE(3281)] = 126200, + [SMALL_STATE(3282)] = 126220, + [SMALL_STATE(3283)] = 126240, + [SMALL_STATE(3284)] = 126260, + [SMALL_STATE(3285)] = 126280, + [SMALL_STATE(3286)] = 126300, + [SMALL_STATE(3287)] = 126320, + [SMALL_STATE(3288)] = 126340, + [SMALL_STATE(3289)] = 126360, + [SMALL_STATE(3290)] = 126378, + [SMALL_STATE(3291)] = 126398, + [SMALL_STATE(3292)] = 126418, + [SMALL_STATE(3293)] = 126438, + [SMALL_STATE(3294)] = 126456, + [SMALL_STATE(3295)] = 126476, + [SMALL_STATE(3296)] = 126496, + [SMALL_STATE(3297)] = 126516, + [SMALL_STATE(3298)] = 126536, + [SMALL_STATE(3299)] = 126554, + [SMALL_STATE(3300)] = 126574, + [SMALL_STATE(3301)] = 126592, + [SMALL_STATE(3302)] = 126612, + [SMALL_STATE(3303)] = 126632, + [SMALL_STATE(3304)] = 126652, + [SMALL_STATE(3305)] = 126672, + [SMALL_STATE(3306)] = 126692, + [SMALL_STATE(3307)] = 126712, + [SMALL_STATE(3308)] = 126730, + [SMALL_STATE(3309)] = 126750, + [SMALL_STATE(3310)] = 126770, + [SMALL_STATE(3311)] = 126790, + [SMALL_STATE(3312)] = 126810, + [SMALL_STATE(3313)] = 126830, + [SMALL_STATE(3314)] = 126850, + [SMALL_STATE(3315)] = 126870, + [SMALL_STATE(3316)] = 126890, + [SMALL_STATE(3317)] = 126908, + [SMALL_STATE(3318)] = 126926, + [SMALL_STATE(3319)] = 126944, + [SMALL_STATE(3320)] = 126964, + [SMALL_STATE(3321)] = 126984, + [SMALL_STATE(3322)] = 127004, + [SMALL_STATE(3323)] = 127024, + [SMALL_STATE(3324)] = 127044, + [SMALL_STATE(3325)] = 127064, + [SMALL_STATE(3326)] = 127082, + [SMALL_STATE(3327)] = 127102, + [SMALL_STATE(3328)] = 127120, + [SMALL_STATE(3329)] = 127140, + [SMALL_STATE(3330)] = 127160, + [SMALL_STATE(3331)] = 127180, + [SMALL_STATE(3332)] = 127200, + [SMALL_STATE(3333)] = 127218, + [SMALL_STATE(3334)] = 127238, + [SMALL_STATE(3335)] = 127258, + [SMALL_STATE(3336)] = 127278, + [SMALL_STATE(3337)] = 127298, + [SMALL_STATE(3338)] = 127318, + [SMALL_STATE(3339)] = 127338, + [SMALL_STATE(3340)] = 127358, + [SMALL_STATE(3341)] = 127378, + [SMALL_STATE(3342)] = 127398, + [SMALL_STATE(3343)] = 127418, + [SMALL_STATE(3344)] = 127438, + [SMALL_STATE(3345)] = 127458, + [SMALL_STATE(3346)] = 127478, + [SMALL_STATE(3347)] = 127498, + [SMALL_STATE(3348)] = 127518, + [SMALL_STATE(3349)] = 127538, + [SMALL_STATE(3350)] = 127558, + [SMALL_STATE(3351)] = 127578, + [SMALL_STATE(3352)] = 127596, + [SMALL_STATE(3353)] = 127616, + [SMALL_STATE(3354)] = 127636, + [SMALL_STATE(3355)] = 127656, + [SMALL_STATE(3356)] = 127674, + [SMALL_STATE(3357)] = 127694, + [SMALL_STATE(3358)] = 127714, + [SMALL_STATE(3359)] = 127734, + [SMALL_STATE(3360)] = 127754, + [SMALL_STATE(3361)] = 127772, + [SMALL_STATE(3362)] = 127792, + [SMALL_STATE(3363)] = 127812, + [SMALL_STATE(3364)] = 127832, + [SMALL_STATE(3365)] = 127852, + [SMALL_STATE(3366)] = 127872, + [SMALL_STATE(3367)] = 127892, + [SMALL_STATE(3368)] = 127912, + [SMALL_STATE(3369)] = 127932, + [SMALL_STATE(3370)] = 127950, + [SMALL_STATE(3371)] = 127970, + [SMALL_STATE(3372)] = 127990, + [SMALL_STATE(3373)] = 128010, + [SMALL_STATE(3374)] = 128030, + [SMALL_STATE(3375)] = 128050, + [SMALL_STATE(3376)] = 128067, + [SMALL_STATE(3377)] = 128084, + [SMALL_STATE(3378)] = 128101, + [SMALL_STATE(3379)] = 128118, + [SMALL_STATE(3380)] = 128135, + [SMALL_STATE(3381)] = 128152, + [SMALL_STATE(3382)] = 128169, + [SMALL_STATE(3383)] = 128186, + [SMALL_STATE(3384)] = 128203, + [SMALL_STATE(3385)] = 128220, + [SMALL_STATE(3386)] = 128237, + [SMALL_STATE(3387)] = 128254, + [SMALL_STATE(3388)] = 128271, + [SMALL_STATE(3389)] = 128288, + [SMALL_STATE(3390)] = 128305, + [SMALL_STATE(3391)] = 128322, + [SMALL_STATE(3392)] = 128339, + [SMALL_STATE(3393)] = 128356, + [SMALL_STATE(3394)] = 128373, + [SMALL_STATE(3395)] = 128390, + [SMALL_STATE(3396)] = 128407, + [SMALL_STATE(3397)] = 128424, + [SMALL_STATE(3398)] = 128441, + [SMALL_STATE(3399)] = 128458, + [SMALL_STATE(3400)] = 128475, + [SMALL_STATE(3401)] = 128492, + [SMALL_STATE(3402)] = 128509, + [SMALL_STATE(3403)] = 128526, + [SMALL_STATE(3404)] = 128543, + [SMALL_STATE(3405)] = 128560, + [SMALL_STATE(3406)] = 128577, + [SMALL_STATE(3407)] = 128594, + [SMALL_STATE(3408)] = 128611, + [SMALL_STATE(3409)] = 128628, + [SMALL_STATE(3410)] = 128645, + [SMALL_STATE(3411)] = 128662, + [SMALL_STATE(3412)] = 128679, + [SMALL_STATE(3413)] = 128696, + [SMALL_STATE(3414)] = 128713, + [SMALL_STATE(3415)] = 128730, + [SMALL_STATE(3416)] = 128747, + [SMALL_STATE(3417)] = 128764, + [SMALL_STATE(3418)] = 128781, + [SMALL_STATE(3419)] = 128798, + [SMALL_STATE(3420)] = 128815, + [SMALL_STATE(3421)] = 128832, + [SMALL_STATE(3422)] = 128849, + [SMALL_STATE(3423)] = 128866, + [SMALL_STATE(3424)] = 128883, + [SMALL_STATE(3425)] = 128900, + [SMALL_STATE(3426)] = 128917, + [SMALL_STATE(3427)] = 128934, + [SMALL_STATE(3428)] = 128951, + [SMALL_STATE(3429)] = 128968, + [SMALL_STATE(3430)] = 128985, + [SMALL_STATE(3431)] = 129002, + [SMALL_STATE(3432)] = 129019, + [SMALL_STATE(3433)] = 129036, + [SMALL_STATE(3434)] = 129053, + [SMALL_STATE(3435)] = 129070, + [SMALL_STATE(3436)] = 129087, + [SMALL_STATE(3437)] = 129104, + [SMALL_STATE(3438)] = 129121, + [SMALL_STATE(3439)] = 129138, + [SMALL_STATE(3440)] = 129155, + [SMALL_STATE(3441)] = 129172, + [SMALL_STATE(3442)] = 129189, + [SMALL_STATE(3443)] = 129206, + [SMALL_STATE(3444)] = 129223, + [SMALL_STATE(3445)] = 129240, + [SMALL_STATE(3446)] = 129257, + [SMALL_STATE(3447)] = 129274, + [SMALL_STATE(3448)] = 129291, + [SMALL_STATE(3449)] = 129308, + [SMALL_STATE(3450)] = 129325, + [SMALL_STATE(3451)] = 129342, + [SMALL_STATE(3452)] = 129359, + [SMALL_STATE(3453)] = 129376, + [SMALL_STATE(3454)] = 129393, + [SMALL_STATE(3455)] = 129410, + [SMALL_STATE(3456)] = 129427, + [SMALL_STATE(3457)] = 129444, + [SMALL_STATE(3458)] = 129461, + [SMALL_STATE(3459)] = 129478, + [SMALL_STATE(3460)] = 129495, + [SMALL_STATE(3461)] = 129512, + [SMALL_STATE(3462)] = 129529, + [SMALL_STATE(3463)] = 129546, + [SMALL_STATE(3464)] = 129563, + [SMALL_STATE(3465)] = 129580, + [SMALL_STATE(3466)] = 129597, + [SMALL_STATE(3467)] = 129614, + [SMALL_STATE(3468)] = 129631, + [SMALL_STATE(3469)] = 129648, + [SMALL_STATE(3470)] = 129665, + [SMALL_STATE(3471)] = 129682, + [SMALL_STATE(3472)] = 129699, + [SMALL_STATE(3473)] = 129716, + [SMALL_STATE(3474)] = 129733, + [SMALL_STATE(3475)] = 129750, + [SMALL_STATE(3476)] = 129767, + [SMALL_STATE(3477)] = 129784, + [SMALL_STATE(3478)] = 129801, + [SMALL_STATE(3479)] = 129818, + [SMALL_STATE(3480)] = 129835, + [SMALL_STATE(3481)] = 129852, + [SMALL_STATE(3482)] = 129869, + [SMALL_STATE(3483)] = 129886, + [SMALL_STATE(3484)] = 129903, + [SMALL_STATE(3485)] = 129920, + [SMALL_STATE(3486)] = 129937, + [SMALL_STATE(3487)] = 129954, + [SMALL_STATE(3488)] = 129971, + [SMALL_STATE(3489)] = 129988, + [SMALL_STATE(3490)] = 130005, + [SMALL_STATE(3491)] = 130022, + [SMALL_STATE(3492)] = 130039, + [SMALL_STATE(3493)] = 130056, + [SMALL_STATE(3494)] = 130073, + [SMALL_STATE(3495)] = 130090, + [SMALL_STATE(3496)] = 130107, + [SMALL_STATE(3497)] = 130124, + [SMALL_STATE(3498)] = 130141, + [SMALL_STATE(3499)] = 130158, + [SMALL_STATE(3500)] = 130175, + [SMALL_STATE(3501)] = 130192, + [SMALL_STATE(3502)] = 130209, + [SMALL_STATE(3503)] = 130226, + [SMALL_STATE(3504)] = 130243, + [SMALL_STATE(3505)] = 130260, + [SMALL_STATE(3506)] = 130277, + [SMALL_STATE(3507)] = 130294, + [SMALL_STATE(3508)] = 130311, + [SMALL_STATE(3509)] = 130328, + [SMALL_STATE(3510)] = 130345, + [SMALL_STATE(3511)] = 130362, + [SMALL_STATE(3512)] = 130379, + [SMALL_STATE(3513)] = 130396, + [SMALL_STATE(3514)] = 130413, + [SMALL_STATE(3515)] = 130430, + [SMALL_STATE(3516)] = 130447, + [SMALL_STATE(3517)] = 130464, + [SMALL_STATE(3518)] = 130481, + [SMALL_STATE(3519)] = 130498, + [SMALL_STATE(3520)] = 130515, + [SMALL_STATE(3521)] = 130532, + [SMALL_STATE(3522)] = 130549, + [SMALL_STATE(3523)] = 130566, + [SMALL_STATE(3524)] = 130583, + [SMALL_STATE(3525)] = 130600, + [SMALL_STATE(3526)] = 130617, + [SMALL_STATE(3527)] = 130634, + [SMALL_STATE(3528)] = 130651, + [SMALL_STATE(3529)] = 130668, + [SMALL_STATE(3530)] = 130685, + [SMALL_STATE(3531)] = 130702, + [SMALL_STATE(3532)] = 130719, + [SMALL_STATE(3533)] = 130736, + [SMALL_STATE(3534)] = 130753, + [SMALL_STATE(3535)] = 130770, + [SMALL_STATE(3536)] = 130787, + [SMALL_STATE(3537)] = 130804, + [SMALL_STATE(3538)] = 130821, + [SMALL_STATE(3539)] = 130838, + [SMALL_STATE(3540)] = 130855, + [SMALL_STATE(3541)] = 130872, + [SMALL_STATE(3542)] = 130889, + [SMALL_STATE(3543)] = 130906, + [SMALL_STATE(3544)] = 130923, + [SMALL_STATE(3545)] = 130940, + [SMALL_STATE(3546)] = 130957, + [SMALL_STATE(3547)] = 130974, + [SMALL_STATE(3548)] = 130991, + [SMALL_STATE(3549)] = 131008, + [SMALL_STATE(3550)] = 131025, + [SMALL_STATE(3551)] = 131042, + [SMALL_STATE(3552)] = 131059, + [SMALL_STATE(3553)] = 131076, + [SMALL_STATE(3554)] = 131093, + [SMALL_STATE(3555)] = 131110, + [SMALL_STATE(3556)] = 131127, + [SMALL_STATE(3557)] = 131144, + [SMALL_STATE(3558)] = 131161, + [SMALL_STATE(3559)] = 131178, + [SMALL_STATE(3560)] = 131195, + [SMALL_STATE(3561)] = 131212, + [SMALL_STATE(3562)] = 131229, + [SMALL_STATE(3563)] = 131246, + [SMALL_STATE(3564)] = 131263, + [SMALL_STATE(3565)] = 131280, + [SMALL_STATE(3566)] = 131297, + [SMALL_STATE(3567)] = 131314, + [SMALL_STATE(3568)] = 131331, + [SMALL_STATE(3569)] = 131348, + [SMALL_STATE(3570)] = 131365, + [SMALL_STATE(3571)] = 131382, + [SMALL_STATE(3572)] = 131399, + [SMALL_STATE(3573)] = 131416, + [SMALL_STATE(3574)] = 131433, + [SMALL_STATE(3575)] = 131450, + [SMALL_STATE(3576)] = 131467, + [SMALL_STATE(3577)] = 131484, + [SMALL_STATE(3578)] = 131501, + [SMALL_STATE(3579)] = 131518, + [SMALL_STATE(3580)] = 131535, + [SMALL_STATE(3581)] = 131552, + [SMALL_STATE(3582)] = 131569, + [SMALL_STATE(3583)] = 131586, + [SMALL_STATE(3584)] = 131603, + [SMALL_STATE(3585)] = 131620, + [SMALL_STATE(3586)] = 131637, + [SMALL_STATE(3587)] = 131654, + [SMALL_STATE(3588)] = 131671, + [SMALL_STATE(3589)] = 131688, + [SMALL_STATE(3590)] = 131705, + [SMALL_STATE(3591)] = 131722, + [SMALL_STATE(3592)] = 131739, + [SMALL_STATE(3593)] = 131756, + [SMALL_STATE(3594)] = 131773, + [SMALL_STATE(3595)] = 131790, + [SMALL_STATE(3596)] = 131807, + [SMALL_STATE(3597)] = 131824, + [SMALL_STATE(3598)] = 131841, + [SMALL_STATE(3599)] = 131858, + [SMALL_STATE(3600)] = 131875, + [SMALL_STATE(3601)] = 131892, + [SMALL_STATE(3602)] = 131909, + [SMALL_STATE(3603)] = 131926, + [SMALL_STATE(3604)] = 131943, + [SMALL_STATE(3605)] = 131960, + [SMALL_STATE(3606)] = 131977, + [SMALL_STATE(3607)] = 131994, + [SMALL_STATE(3608)] = 132011, + [SMALL_STATE(3609)] = 132028, + [SMALL_STATE(3610)] = 132045, + [SMALL_STATE(3611)] = 132062, + [SMALL_STATE(3612)] = 132079, + [SMALL_STATE(3613)] = 132096, + [SMALL_STATE(3614)] = 132113, + [SMALL_STATE(3615)] = 132130, + [SMALL_STATE(3616)] = 132147, + [SMALL_STATE(3617)] = 132164, + [SMALL_STATE(3618)] = 132181, + [SMALL_STATE(3619)] = 132198, + [SMALL_STATE(3620)] = 132215, + [SMALL_STATE(3621)] = 132232, + [SMALL_STATE(3622)] = 132249, + [SMALL_STATE(3623)] = 132266, + [SMALL_STATE(3624)] = 132283, + [SMALL_STATE(3625)] = 132300, + [SMALL_STATE(3626)] = 132317, + [SMALL_STATE(3627)] = 132334, + [SMALL_STATE(3628)] = 132351, + [SMALL_STATE(3629)] = 132368, + [SMALL_STATE(3630)] = 132385, + [SMALL_STATE(3631)] = 132402, + [SMALL_STATE(3632)] = 132419, + [SMALL_STATE(3633)] = 132436, + [SMALL_STATE(3634)] = 132453, + [SMALL_STATE(3635)] = 132470, + [SMALL_STATE(3636)] = 132487, + [SMALL_STATE(3637)] = 132504, + [SMALL_STATE(3638)] = 132521, + [SMALL_STATE(3639)] = 132538, + [SMALL_STATE(3640)] = 132555, + [SMALL_STATE(3641)] = 132572, + [SMALL_STATE(3642)] = 132589, + [SMALL_STATE(3643)] = 132606, + [SMALL_STATE(3644)] = 132623, + [SMALL_STATE(3645)] = 132640, + [SMALL_STATE(3646)] = 132657, + [SMALL_STATE(3647)] = 132674, + [SMALL_STATE(3648)] = 132691, + [SMALL_STATE(3649)] = 132708, + [SMALL_STATE(3650)] = 132725, + [SMALL_STATE(3651)] = 132742, + [SMALL_STATE(3652)] = 132759, + [SMALL_STATE(3653)] = 132776, + [SMALL_STATE(3654)] = 132793, + [SMALL_STATE(3655)] = 132810, + [SMALL_STATE(3656)] = 132827, + [SMALL_STATE(3657)] = 132844, + [SMALL_STATE(3658)] = 132861, + [SMALL_STATE(3659)] = 132878, + [SMALL_STATE(3660)] = 132895, + [SMALL_STATE(3661)] = 132912, + [SMALL_STATE(3662)] = 132929, + [SMALL_STATE(3663)] = 132946, + [SMALL_STATE(3664)] = 132963, + [SMALL_STATE(3665)] = 132980, + [SMALL_STATE(3666)] = 132997, + [SMALL_STATE(3667)] = 133014, + [SMALL_STATE(3668)] = 133031, + [SMALL_STATE(3669)] = 133048, + [SMALL_STATE(3670)] = 133065, + [SMALL_STATE(3671)] = 133082, + [SMALL_STATE(3672)] = 133099, + [SMALL_STATE(3673)] = 133116, + [SMALL_STATE(3674)] = 133133, + [SMALL_STATE(3675)] = 133150, + [SMALL_STATE(3676)] = 133167, + [SMALL_STATE(3677)] = 133184, + [SMALL_STATE(3678)] = 133201, + [SMALL_STATE(3679)] = 133218, + [SMALL_STATE(3680)] = 133235, + [SMALL_STATE(3681)] = 133252, + [SMALL_STATE(3682)] = 133269, + [SMALL_STATE(3683)] = 133286, + [SMALL_STATE(3684)] = 133303, + [SMALL_STATE(3685)] = 133320, + [SMALL_STATE(3686)] = 133337, + [SMALL_STATE(3687)] = 133354, + [SMALL_STATE(3688)] = 133371, + [SMALL_STATE(3689)] = 133388, + [SMALL_STATE(3690)] = 133405, + [SMALL_STATE(3691)] = 133422, + [SMALL_STATE(3692)] = 133439, + [SMALL_STATE(3693)] = 133456, + [SMALL_STATE(3694)] = 133473, + [SMALL_STATE(3695)] = 133490, + [SMALL_STATE(3696)] = 133507, + [SMALL_STATE(3697)] = 133524, + [SMALL_STATE(3698)] = 133541, + [SMALL_STATE(3699)] = 133558, + [SMALL_STATE(3700)] = 133575, + [SMALL_STATE(3701)] = 133592, + [SMALL_STATE(3702)] = 133609, + [SMALL_STATE(3703)] = 133626, + [SMALL_STATE(3704)] = 133643, + [SMALL_STATE(3705)] = 133660, + [SMALL_STATE(3706)] = 133677, + [SMALL_STATE(3707)] = 133694, + [SMALL_STATE(3708)] = 133711, + [SMALL_STATE(3709)] = 133728, + [SMALL_STATE(3710)] = 133745, + [SMALL_STATE(3711)] = 133762, + [SMALL_STATE(3712)] = 133779, + [SMALL_STATE(3713)] = 133796, + [SMALL_STATE(3714)] = 133813, + [SMALL_STATE(3715)] = 133830, + [SMALL_STATE(3716)] = 133847, + [SMALL_STATE(3717)] = 133864, + [SMALL_STATE(3718)] = 133881, + [SMALL_STATE(3719)] = 133898, + [SMALL_STATE(3720)] = 133915, + [SMALL_STATE(3721)] = 133932, + [SMALL_STATE(3722)] = 133949, + [SMALL_STATE(3723)] = 133966, + [SMALL_STATE(3724)] = 133983, + [SMALL_STATE(3725)] = 134000, + [SMALL_STATE(3726)] = 134017, + [SMALL_STATE(3727)] = 134034, + [SMALL_STATE(3728)] = 134051, + [SMALL_STATE(3729)] = 134068, + [SMALL_STATE(3730)] = 134085, + [SMALL_STATE(3731)] = 134102, + [SMALL_STATE(3732)] = 134119, + [SMALL_STATE(3733)] = 134136, + [SMALL_STATE(3734)] = 134153, + [SMALL_STATE(3735)] = 134170, + [SMALL_STATE(3736)] = 134187, + [SMALL_STATE(3737)] = 134204, + [SMALL_STATE(3738)] = 134221, + [SMALL_STATE(3739)] = 134238, + [SMALL_STATE(3740)] = 134255, + [SMALL_STATE(3741)] = 134272, + [SMALL_STATE(3742)] = 134289, + [SMALL_STATE(3743)] = 134306, + [SMALL_STATE(3744)] = 134323, + [SMALL_STATE(3745)] = 134340, + [SMALL_STATE(3746)] = 134357, + [SMALL_STATE(3747)] = 134374, + [SMALL_STATE(3748)] = 134391, + [SMALL_STATE(3749)] = 134408, + [SMALL_STATE(3750)] = 134425, + [SMALL_STATE(3751)] = 134442, + [SMALL_STATE(3752)] = 134459, + [SMALL_STATE(3753)] = 134476, + [SMALL_STATE(3754)] = 134493, + [SMALL_STATE(3755)] = 134510, + [SMALL_STATE(3756)] = 134527, + [SMALL_STATE(3757)] = 134544, + [SMALL_STATE(3758)] = 134561, + [SMALL_STATE(3759)] = 134578, + [SMALL_STATE(3760)] = 134595, + [SMALL_STATE(3761)] = 134612, + [SMALL_STATE(3762)] = 134629, + [SMALL_STATE(3763)] = 134646, + [SMALL_STATE(3764)] = 134663, + [SMALL_STATE(3765)] = 134680, + [SMALL_STATE(3766)] = 134697, + [SMALL_STATE(3767)] = 134714, + [SMALL_STATE(3768)] = 134731, + [SMALL_STATE(3769)] = 134748, + [SMALL_STATE(3770)] = 134765, + [SMALL_STATE(3771)] = 134782, + [SMALL_STATE(3772)] = 134799, + [SMALL_STATE(3773)] = 134816, + [SMALL_STATE(3774)] = 134833, + [SMALL_STATE(3775)] = 134850, + [SMALL_STATE(3776)] = 134867, + [SMALL_STATE(3777)] = 134884, + [SMALL_STATE(3778)] = 134901, + [SMALL_STATE(3779)] = 134918, + [SMALL_STATE(3780)] = 134935, + [SMALL_STATE(3781)] = 134952, + [SMALL_STATE(3782)] = 134969, + [SMALL_STATE(3783)] = 134986, + [SMALL_STATE(3784)] = 135003, + [SMALL_STATE(3785)] = 135020, + [SMALL_STATE(3786)] = 135037, + [SMALL_STATE(3787)] = 135054, + [SMALL_STATE(3788)] = 135071, + [SMALL_STATE(3789)] = 135088, + [SMALL_STATE(3790)] = 135105, + [SMALL_STATE(3791)] = 135122, + [SMALL_STATE(3792)] = 135139, + [SMALL_STATE(3793)] = 135156, + [SMALL_STATE(3794)] = 135173, + [SMALL_STATE(3795)] = 135190, + [SMALL_STATE(3796)] = 135207, + [SMALL_STATE(3797)] = 135224, + [SMALL_STATE(3798)] = 135241, + [SMALL_STATE(3799)] = 135258, + [SMALL_STATE(3800)] = 135275, + [SMALL_STATE(3801)] = 135292, + [SMALL_STATE(3802)] = 135309, + [SMALL_STATE(3803)] = 135326, + [SMALL_STATE(3804)] = 135343, + [SMALL_STATE(3805)] = 135360, + [SMALL_STATE(3806)] = 135377, + [SMALL_STATE(3807)] = 135394, + [SMALL_STATE(3808)] = 135411, + [SMALL_STATE(3809)] = 135428, + [SMALL_STATE(3810)] = 135445, + [SMALL_STATE(3811)] = 135449, + [SMALL_STATE(3812)] = 135453, + [SMALL_STATE(3813)] = 135457, }; static const TSParseActionEntry ts_parse_actions[] = { [0] = {.entry = {.count = 0, .reusable = false}}, [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), - [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3264), - [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3300), - [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3313), + [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3684), + [5] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3808), + [7] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3807), [9] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_code, 0), - [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), - [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2088), - [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1016), - [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1438), - [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2533), - [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2092), - [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(467), - [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1820), - [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1704), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3312), - [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(362), - [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3311), - [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1812), - [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(479), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2562), - [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3308), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1797), - [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2032), - [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3306), - [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3305), - [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(454), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2563), - [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(331), - [57] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2738), - [59] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2086), - [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1075), - [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1446), - [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2292), - [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2085), - [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(401), - [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1832), - [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1714), - [75] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3168), - [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(361), - [79] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3266), - [81] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1809), - [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(512), - [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2669), - [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3170), - [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1778), - [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2034), - [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3299), - [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3171), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), - [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2561), - [101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(311), - [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2556), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(310), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(308), - [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(283), - [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2144), - [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2145), - [115] = {.entry = {.count = 1, .reusable = false}}, SHIFT(397), - [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(298), - [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1700), - [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(375), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(372), - [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(469), - [127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(402), - [129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2208), - [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2668), - [133] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3257), - [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(510), - [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3173), - [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2559), - [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1627), - [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2271), - [145] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2938), - [147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2934), - [149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2942), - [151] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3112), - [153] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3139), - [155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3191), - [157] = {.entry = {.count = 1, .reusable = false}}, SHIFT(529), - [159] = {.entry = {.count = 1, .reusable = false}}, SHIFT(506), - [161] = {.entry = {.count = 1, .reusable = false}}, SHIFT(483), - [163] = {.entry = {.count = 1, .reusable = false}}, SHIFT(502), - [165] = {.entry = {.count = 1, .reusable = false}}, SHIFT(370), - [167] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2275), - [169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2634), - [171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(482), - [173] = {.entry = {.count = 1, .reusable = false}}, SHIFT(408), - [175] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1533), - [177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3185), - [179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2664), - [181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2795), - [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1689), - [185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3107), - [187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3225), - [189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), - [191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(535), - [193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(660), - [195] = {.entry = {.count = 1, .reusable = false}}, SHIFT(832), - [197] = {.entry = {.count = 1, .reusable = false}}, SHIFT(776), - [199] = {.entry = {.count = 1, .reusable = false}}, SHIFT(771), - [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), - [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3005), - [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(309), - [207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(313), - [209] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2909), - [211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2875), - [213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2918), - [215] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2829), - [217] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2771), - [219] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2876), - [221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2854), - [223] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2839), - [225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2827), - [227] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2886), - [229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2892), - [231] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2665), - [233] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_body, 1), - [235] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(331), - [238] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), - [240] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2086), - [243] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1075), - [246] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1446), - [249] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2292), - [252] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2085), - [255] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(401), - [258] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1832), - [261] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1714), - [264] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3168), - [267] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(361), - [270] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3266), - [273] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1809), - [276] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(512), - [279] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2669), - [282] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3170), - [285] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1778), - [288] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2034), - [291] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3299), - [294] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3171), - [297] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(507), - [300] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2561), - [303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_code_repeat1, 2), - [305] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(332), - [308] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2088), - [311] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1016), - [314] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1438), - [317] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2533), - [320] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2092), - [323] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(467), - [326] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1820), - [329] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1704), - [332] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3312), - [335] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(362), - [338] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3311), - [341] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1812), - [344] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(479), - [347] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2562), - [350] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3308), - [353] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1797), - [356] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2032), - [359] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3306), - [362] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3305), - [365] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(454), - [368] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2563), - [371] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_code, 1), - [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3264), - [375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3300), - [377] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_name, 2), - [379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3313), - [381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_name, 2), - [383] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2995), - [385] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_name_repeat1, 2), - [387] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), - [389] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(2995), - [392] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_single_quoted_string, 3), - [394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_single_quoted_string, 3), - [396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_string, 3), - [398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_string, 3), - [400] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_single_quoted_string, 2), - [402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_single_quoted_string, 2), - [404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_string, 2), - [406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_string, 2), - [408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal, 1), - [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal, 1), - [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_number_literal, 1), - [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_number_literal, 1), - [416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2996), - [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__decimal_literal, 3), - [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__decimal_literal, 3), - [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_expression, 4, .production_id = 17), - [424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_expression, 4, .production_id = 17), - [426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_expression, 2, .production_id = 6), - [428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_expression, 2, .production_id = 6), - [430] = {.entry = {.count = 1, .reusable = false}}, SHIFT(733), - [432] = {.entry = {.count = 1, .reusable = false}}, SHIFT(831), - [434] = {.entry = {.count = 1, .reusable = false}}, SHIFT(800), - [436] = {.entry = {.count = 1, .reusable = false}}, SHIFT(737), - [438] = {.entry = {.count = 1, .reusable = false}}, SHIFT(624), - [440] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1799), - [442] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1703), - [444] = {.entry = {.count = 1, .reusable = false}}, SHIFT(403), - [446] = {.entry = {.count = 1, .reusable = false}}, SHIFT(626), - [448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3, .production_id = 5), - [450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3, .production_id = 5), - [452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), - [454] = {.entry = {.count = 1, .reusable = false}}, SHIFT(554), - [456] = {.entry = {.count = 1, .reusable = false}}, SHIFT(464), - [458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(566), - [460] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4, .production_id = 5), - [462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4, .production_id = 5), - [464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 18), - [466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 18), - [468] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2), - [470] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2), - [472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 5), - [474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 5), - [476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean_literal, 1), - [478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean_literal, 1), - [480] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 29), - [482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 29), - [484] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1), - [486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1), - [488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(301), - [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2921), - [492] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__binary_expression, 1), - [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__binary_expression, 1), - [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 4, .production_id = 18), - [498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 4, .production_id = 18), - [500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__unary_minus_expressions, 1), - [502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__unary_minus_expressions, 1), - [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3), - [506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3), - [508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 4), - [510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 4), - [512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 28), - [514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 28), - [516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 7, .production_id = 42), - [518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 7, .production_id = 42), - [520] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 29), - [522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 29), - [524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_available_expression, 2), - [526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_available_expression, 2), - [528] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 3), - [530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 3), - [532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 42), - [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 42), - [536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 28), - [538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 28), - [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 6), - [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 6), - [544] = {.entry = {.count = 1, .reusable = false}}, SHIFT(345), - [546] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2472), - [548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(929), - [550] = {.entry = {.count = 1, .reusable = false}}, SHIFT(534), - [552] = {.entry = {.count = 1, .reusable = false}}, SHIFT(541), - [554] = {.entry = {.count = 1, .reusable = false}}, SHIFT(492), - [556] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2103), - [558] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2106), - [560] = {.entry = {.count = 1, .reusable = false}}, SHIFT(290), - [562] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1707), - [564] = {.entry = {.count = 1, .reusable = false}}, SHIFT(468), - [566] = {.entry = {.count = 1, .reusable = false}}, SHIFT(472), - [568] = {.entry = {.count = 1, .reusable = false}}, SHIFT(475), - [570] = {.entry = {.count = 1, .reusable = false}}, SHIFT(503), - [572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2448), - [574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(442), - [576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2564), - [578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(488), - [580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2931), - [582] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3295), - [584] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1621), - [586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2427), - [588] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), - [590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), - [592] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2921), - [595] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1145), - [597] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1205), - [599] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1062), - [601] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1083), - [603] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2539), - [605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(921), - [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_access, 2, .production_id = 4), - [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_access, 2, .production_id = 4), - [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 9), - [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 9), - [615] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), - [617] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ambiguous_expression, 2), - [619] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1401), - [621] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1403), - [623] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1404), - [625] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1397), - [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_expression, 3), - [629] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_locked_expression, 2), - [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_current_changed_expression, 2), - [633] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 10), - [635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 10), - [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 1), - [639] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), - [641] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2571), - [643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3260), - [645] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 3), - [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), - [649] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 3), - [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 6, .production_id = 41), - [653] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_expression, 3), - [655] = {.entry = {.count = 1, .reusable = false}}, SHIFT(895), - [657] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), - [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1185), - [661] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(345), - [664] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2472), - [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), - [669] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(534), - [672] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(541), - [675] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(492), - [678] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2103), - [681] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2106), - [684] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(406), - [687] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(1707), - [690] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(468), - [693] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(472), - [696] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(475), - [699] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(503), - [702] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2448), - [705] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2564), - [708] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(488), - [711] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(3295), - [714] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(1621), - [717] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2427), - [720] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1148), - [722] = {.entry = {.count = 1, .reusable = false}}, SHIFT(925), - [724] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2518), - [726] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2536), - [728] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3260), - [731] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1158), - [733] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1184), - [735] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2571), - [738] = {.entry = {.count = 1, .reusable = false}}, SHIFT(918), - [740] = {.entry = {.count = 1, .reusable = false}}, SHIFT(922), - [742] = {.entry = {.count = 1, .reusable = false}}, SHIFT(593), - [744] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2185), - [746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), - [748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), - [750] = {.entry = {.count = 1, .reusable = false}}, SHIFT(628), - [752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2091), - [754] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2113), - [756] = {.entry = {.count = 1, .reusable = false}}, SHIFT(480), - [758] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1713), - [760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(413), - [762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(414), - [764] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), - [766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(432), - [768] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2422), - [770] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2585), - [772] = {.entry = {.count = 1, .reusable = false}}, SHIFT(513), - [774] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3223), - [776] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1639), - [778] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2424), - [780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(567), - [782] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1696), - [784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(466), - [786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(465), - [788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(440), - [790] = {.entry = {.count = 1, .reusable = false}}, SHIFT(426), - [792] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), - [794] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1683), - [796] = {.entry = {.count = 1, .reusable = false}}, SHIFT(651), - [798] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2273), - [800] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), - [802] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), - [804] = {.entry = {.count = 1, .reusable = false}}, SHIFT(742), - [806] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2114), - [808] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2131), - [810] = {.entry = {.count = 1, .reusable = false}}, SHIFT(504), - [812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1701), - [814] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), - [816] = {.entry = {.count = 1, .reusable = false}}, SHIFT(385), - [818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), - [820] = {.entry = {.count = 1, .reusable = false}}, SHIFT(389), - [822] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2300), - [824] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2598), - [826] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), - [828] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3218), - [830] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1662), - [832] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2302), - [834] = {.entry = {.count = 1, .reusable = false}}, SHIFT(517), - [836] = {.entry = {.count = 1, .reusable = false}}, SHIFT(431), - [838] = {.entry = {.count = 1, .reusable = false}}, SHIFT(429), - [840] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), - [842] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), - [844] = {.entry = {.count = 1, .reusable = false}}, SHIFT(493), - [846] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1622), - [848] = {.entry = {.count = 1, .reusable = false}}, SHIFT(677), - [850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2218), - [852] = {.entry = {.count = 1, .reusable = false}}, SHIFT(821), - [854] = {.entry = {.count = 1, .reusable = false}}, SHIFT(810), - [856] = {.entry = {.count = 1, .reusable = false}}, SHIFT(797), - [858] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2132), - [860] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2177), - [862] = {.entry = {.count = 1, .reusable = false}}, SHIFT(434), - [864] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1695), - [866] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), - [868] = {.entry = {.count = 1, .reusable = false}}, SHIFT(417), - [870] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), - [872] = {.entry = {.count = 1, .reusable = false}}, SHIFT(425), - [874] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2188), - [876] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2614), - [878] = {.entry = {.count = 1, .reusable = false}}, SHIFT(487), - [880] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3212), - [882] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1619), - [884] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2190), - [886] = {.entry = {.count = 1, .reusable = false}}, SHIFT(746), - [888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 4), - [890] = {.entry = {.count = 1, .reusable = false}}, SHIFT(533), - [892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3258), - [894] = {.entry = {.count = 1, .reusable = false}}, SHIFT(719), - [896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_expression, 3), - [898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), - [900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1404), - [902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1401), - [904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), - [906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_locked_expression, 2), - [908] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 3), - [910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), - [912] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_current_changed_expression, 2), - [914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 3), - [916] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 6, .production_id = 41), - [918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_expression, 3), - [920] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ambiguous_expression, 2), - [922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), - [924] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 4), - [926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), - [930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), - [932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1533), - [934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3185), - [936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2664), - [938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2795), - [940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), - [942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), - [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(789), - [946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), - [948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), - [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), - [952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(542), - [954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), - [956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(837), - [958] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), - [960] = {.entry = {.count = 1, .reusable = false}}, SHIFT(307), - [962] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2798), - [964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_where_clause, 2, .production_id = 7), - [966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3186), - [968] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3186), - [971] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), - [973] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2570), - [975] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_option, 2), - [977] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2798), - [980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3081), - [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1991), - [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2008), - [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1950), - [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2020), - [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1952), - [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2071), - [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2077), - [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2053), - [1000] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2570), - [1003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_tuning, 2), - [1005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(656), - [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(631), - [1009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3187), - [1011] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat1, 2), - [1013] = {.entry = {.count = 1, .reusable = false}}, SHIFT(292), - [1015] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2662), - [1017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2983), - [1019] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3107), - [1022] = {.entry = {.count = 1, .reusable = false}}, SHIFT(291), - [1024] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2735), - [1026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3133), - [1028] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 4, .production_id = 27), - [1030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(490), - [1032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3193), - [1034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(379), - [1036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3192), - [1038] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3), - [1040] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call_argument, 1), - [1042] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__while_condition, 2, .production_id = 7), - [1044] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3), - [1046] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2662), - [1049] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(2983), - [1052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1210), - [1054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1190), - [1056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), - [1058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1092), - [1060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), - [1062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), - [1064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(509), - [1066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1280), - [1068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1290), - [1070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [1072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1630), - [1074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), - [1076] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), - [1078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1531), - [1082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), - [1084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), - [1086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [1088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), - [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1524), - [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1520), - [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(799), - [1098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), - [1100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), - [1102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), - [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1175), - [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3134), - [1108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), - [1110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), - [1112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(878), - [1114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3), - [1116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), - [1118] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2735), - [1121] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3133), - [1124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1035), - [1126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), - [1128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(655), - [1130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), - [1132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), - [1134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), - [1136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(892), - [1138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(828), - [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), - [1142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2512), - [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), - [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), - [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(452), - [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(387), - [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(528), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), - [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2970), - [1160] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, .production_id = 7), - [1162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1488), - [1164] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, .production_id = 7), - [1166] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, .production_id = 7), - [1168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1518), - [1170] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, .production_id = 7), - [1172] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2), - [1174] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), - [1176] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), SHIFT_REPEAT(1518), - [1179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(813), - [1181] = {.entry = {.count = 1, .reusable = false}}, SHIFT(835), - [1183] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), SHIFT_REPEAT(1488), - [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2102), - [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2351), - [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), - [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3146), - [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1970), - [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [1200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), - [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), - [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), - [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [1216] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 15, .production_id = 16), - [1218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7, .production_id = 13), - [1220] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7, .production_id = 13), - [1222] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 7, .production_id = 16), - [1224] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 7, .production_id = 16), - [1226] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6, .production_id = 26), - [1228] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6, .production_id = 26), - [1230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 6, .production_id = 40), - [1232] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 6, .production_id = 40), - [1234] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6), - [1236] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6), - [1238] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6, .production_id = 13), - [1240] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6, .production_id = 13), - [1242] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 6, .production_id = 16), - [1244] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 6, .production_id = 16), - [1246] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5, .production_id = 26), - [1248] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5, .production_id = 26), - [1250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 5), - [1252] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 5), - [1254] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5), - [1256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5), - [1258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5, .production_id = 13), - [1260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5, .production_id = 13), - [1262] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 5, .production_id = 16), - [1264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 5, .production_id = 16), - [1266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 4), - [1268] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 4), - [1270] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4, .production_id = 13), - [1272] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4, .production_id = 13), - [1274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4), - [1276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4), - [1278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_terminator, 2), - [1280] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_terminator, 2), - [1282] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 3), - [1284] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7), - [1286] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7), - [1288] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 7, .production_id = 40), - [1290] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 7, .production_id = 40), - [1292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7, .production_id = 26), - [1294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7, .production_id = 26), - [1296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 8, .production_id = 16), - [1298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 8, .production_id = 16), - [1300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8, .production_id = 13), - [1302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8, .production_id = 13), - [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 3), - [1306] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 3), - [1308] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 3), - [1310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 3), - [1312] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 3), - [1314] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abl_statement, 3, .production_id = 1), - [1316] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_abl_statement, 3, .production_id = 1), - [1318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 8, .production_id = 40), - [1320] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 8, .production_id = 40), - [1322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8, .production_id = 26), - [1324] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8, .production_id = 26), - [1326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8), - [1328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8), - [1330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 9, .production_id = 16), - [1332] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 9, .production_id = 16), - [1334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 9, .production_id = 40), - [1336] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 9, .production_id = 40), - [1338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 9, .production_id = 26), - [1340] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 9, .production_id = 26), - [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 10, .production_id = 16), - [1344] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 10, .production_id = 16), - [1346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 10, .production_id = 40), - [1348] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 10, .production_id = 40), - [1350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 11, .production_id = 16), - [1352] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 11, .production_id = 16), - [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 11, .production_id = 40), - [1356] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 11, .production_id = 40), - [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 12, .production_id = 16), - [1360] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 12, .production_id = 16), - [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 12, .production_id = 40), - [1364] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 12, .production_id = 40), - [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 13, .production_id = 16), - [1368] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 13, .production_id = 16), - [1370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 13, .production_id = 40), - [1372] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 13, .production_id = 40), - [1374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 14, .production_id = 16), - [1376] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 14, .production_id = 16), - [1378] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 14, .production_id = 40), - [1380] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 14, .production_id = 40), - [1382] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call_statement, 2), - [1384] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call_statement, 2), - [1386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_assignment, 2), - [1388] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_assignment, 2), - [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 15, .production_id = 16), - [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2), - [1394] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2), - [1396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 15, .production_id = 40), - [1398] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 15, .production_id = 40), - [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 16, .production_id = 40), - [1402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 16, .production_id = 40), - [1404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_abl_statement, 2, .production_id = 1), - [1406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abl_statement, 2, .production_id = 1), - [1408] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 5, .production_id = 57), - [1410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 2), - [1412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 1), - [1414] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__if_do_variant, 1), - [1416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__terminated_statement, 1), - [1418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__if_then_variant, 1), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 2), - [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 2, .production_id = 35), - [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 1), - [1426] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_then_variant, 1), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_do_variant, 1), - [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__terminated_statement, 1), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 5, .production_id = 57), - [1434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 6, .production_id = 32), - [1436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 6, .production_id = 32), - [1438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_scope_statement, 3), - [1440] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_scope_statement, 3), - [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 6, .production_id = 33), - [1444] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 6, .production_id = 33), - [1446] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 8), - [1448] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 8), - [1450] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3291), - [1452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1569), - [1454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1568), - [1456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1596), - [1458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3290), - [1460] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3290), - [1462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3289), - [1464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3288), - [1466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3287), - [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3291), - [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3286), - [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 6), - [1474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 6), - [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 5), - [1478] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 5), - [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_stream_statement, 4, .production_id = 12), - [1482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_stream_statement, 4, .production_id = 12), - [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 9, .production_id = 34), - [1486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 9, .production_id = 34), - [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 9), - [1490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 9), - [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 9, .production_id = 48), - [1494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 9, .production_id = 48), - [1496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 5, .production_id = 26), - [1498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 5, .production_id = 26), - [1500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 6, .production_id = 34), - [1502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 6, .production_id = 34), - [1504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_stream_statement, 6, .production_id = 30), - [1506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_stream_statement, 6, .production_id = 30), - [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 6, .production_id = 31), - [1510] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 6, .production_id = 31), - [1512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 4), - [1514] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 4), - [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 5, .production_id = 16), - [1518] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 5, .production_id = 16), - [1520] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 5), - [1522] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 5), - [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5, .production_id = 25), - [1526] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5, .production_id = 25), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5), - [1530] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5), - [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_stream_statement, 6, .production_id = 30), - [1534] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_stream_statement, 6, .production_id = 30), - [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 5, .production_id = 8), - [1538] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 5, .production_id = 8), - [1540] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5, .production_id = 24), - [1542] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5, .production_id = 24), - [1544] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 5), - [1546] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 5), - [1548] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 9, .production_id = 55), - [1550] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 9, .production_id = 55), - [1552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 5, .production_id = 23), - [1554] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 5, .production_id = 23), - [1556] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 5), - [1558] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 5), - [1560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1), - [1562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1), - [1564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 9), - [1566] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 9), - [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 9, .production_id = 51), - [1570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 9, .production_id = 51), - [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 9, .production_id = 56), - [1574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 9, .production_id = 56), - [1576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2262), - [1578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1823), - [1580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2149), - [1582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_stream_definition, 4), - [1584] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_stream_definition, 4), - [1586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_statement, 1), - [1588] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__loop_statement, 1), - [1590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__stream_statement, 1), - [1592] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__stream_statement, 1), - [1594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 5, .production_id = 13), - [1596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 5, .production_id = 13), - [1598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 10, .production_id = 34), - [1600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 10, .production_id = 34), - [1602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_code_repeat1, 1), - [1604] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 1), - [1606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 10, .production_id = 48), - [1608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 10, .production_id = 48), - [1610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_transaction_statement, 5), - [1612] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_transaction_statement, 5), - [1614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 6), - [1616] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 6), - [1618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 6), - [1620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 6), - [1622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__procedure_terminator, 3), - [1624] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__procedure_terminator, 3), - [1626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_terminator, 3), - [1628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_terminator, 3), - [1630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 10, .production_id = 55), - [1632] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 10, .production_id = 55), - [1634] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3307), - [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3233), - [1638] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3233), - [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3234), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3296), - [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3235), - [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3307), - [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3285), - [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 6, .production_id = 23), - [1652] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 6, .production_id = 23), - [1654] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 10), - [1656] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 10), - [1658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 10, .production_id = 56), - [1660] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 10, .production_id = 56), - [1662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 6, .production_id = 37), - [1664] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 6, .production_id = 37), - [1666] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2), - [1668] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2), - [1670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 6), - [1672] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 6), - [1674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 11, .production_id = 34), - [1676] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 11, .production_id = 34), - [1678] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 11, .production_id = 48), - [1680] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 11, .production_id = 48), - [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 6, .production_id = 24), - [1684] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 6, .production_id = 24), - [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 6, .production_id = 38), - [1688] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 6, .production_id = 38), - [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_terminator, 3), - [1692] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__case_terminator, 3), - [1694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_stream_statement, 4, .production_id = 12), - [1696] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_stream_statement, 4, .production_id = 12), - [1698] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 6, .production_id = 8), - [1700] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 6, .production_id = 8), - [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 6, .production_id = 16), - [1704] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 6, .production_id = 16), - [1706] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 11, .production_id = 55), - [1708] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 11, .production_id = 55), - [1710] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 6), - [1712] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 6), - [1714] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_statement, 6), - [1716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_statement, 6), - [1718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 12, .production_id = 48), - [1720] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 12, .production_id = 48), - [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 3), - [1724] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 3), - [1726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 5, .production_id = 21), - [1728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 5, .production_id = 21), - [1730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 3), - [1732] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 3), - [1734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 5, .production_id = 20), - [1736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 5, .production_id = 20), - [1738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 6, .production_id = 26), - [1740] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 6, .production_id = 26), - [1742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_parameter_definition, 7), - [1744] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_parameter_definition, 7), - [1746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 31), - [1748] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 31), - [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 32), - [1752] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 32), - [1754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 7, .production_id = 43), - [1756] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 7, .production_id = 43), - [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 7), - [1760] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 7), - [1762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 7, .production_id = 34), - [1764] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 7, .production_id = 34), - [1766] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 45), - [1768] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 45), - [1770] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 7, .production_id = 47), - [1772] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 7, .production_id = 47), - [1774] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 3), - [1776] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 3), - [1778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 46), - [1780] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 46), - [1782] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2313), - [1784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1805), - [1786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2100), - [1788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 3, .production_id = 8), - [1790] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 3, .production_id = 8), - [1792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 8, .production_id = 56), - [1794] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 8, .production_id = 56), - [1796] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_statement, 7), - [1798] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_statement, 7), - [1800] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 7, .production_id = 23), - [1802] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 7, .production_id = 23), - [1804] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_transaction_statement, 4), - [1806] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_transaction_statement, 4), - [1808] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 8, .production_id = 51), - [1810] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 8, .production_id = 51), - [1812] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 2), - [1814] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 7, .production_id = 37), - [1816] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 7, .production_id = 37), - [1818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 4, .production_id = 13), - [1820] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 4, .production_id = 13), - [1822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 8, .production_id = 16), - [1824] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 8, .production_id = 16), - [1826] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 7), - [1828] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 7), - [1830] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 8), - [1832] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 8), - [1834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 4), - [1836] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 4), - [1838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 5), - [1840] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 5), - [1842] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 8, .production_id = 37), - [1844] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 8, .production_id = 37), - [1846] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 7, .production_id = 8), - [1848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 7, .production_id = 8), - [1850] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 7, .production_id = 16), - [1852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 7, .production_id = 16), - [1854] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 7, .production_id = 51), - [1856] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 7, .production_id = 51), - [1858] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_statement, 7), - [1860] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_statement, 7), - [1862] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 8, .production_id = 55), - [1864] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 8, .production_id = 55), - [1866] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_terminator, 1), - [1868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_terminator, 1), - [1870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 5, .production_id = 21), - [1872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 5, .production_id = 21), - [1874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 5, .production_id = 20), - [1876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 5, .production_id = 20), - [1878] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_parameter_definition, 8), - [1880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_parameter_definition, 8), - [1882] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 7, .production_id = 48), - [1884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 7, .production_id = 48), - [1886] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 4), - [1888] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 4), - [1890] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__case_terminator, 1), - [1892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 4), - [1894] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 4, .production_id = 8), - [1896] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 4, .production_id = 16), - [1898] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 4), - [1900] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 4), - [1902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_terminator, 1), - [1904] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 2), - [1906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 4), - [1908] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 8, .production_id = 48), - [1910] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 8, .production_id = 48), - [1912] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 8, .production_id = 52), - [1914] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 8, .production_id = 52), - [1916] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 4, .production_id = 8), - [1918] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 8, .production_id = 46), - [1920] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 8, .production_id = 46), - [1922] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 8, .production_id = 45), - [1924] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 8, .production_id = 45), - [1926] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 8, .production_id = 34), - [1928] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 8, .production_id = 34), - [1930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 4, .production_id = 16), - [1932] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 4), - [1934] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 8), - [1936] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 8), - [1938] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 4), - [1940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1942] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__comparison_operator, 1), - [1944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), - [1946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [1948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [1950] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__multiplicative_operator, 1), - [1952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), - [1954] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__logical_operator, 1), - [1956] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__additive_operator, 1), - [1958] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_aggregate, 1), - [1960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [1962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [1964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [1966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [1968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), - [1970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 3, .production_id = 35), - [1972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [1974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [1976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [1978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), - [1980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [1982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [1986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), - [1988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [1990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), - [1992] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2739), - [1994] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1580), - [1996] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 4, .production_id = 35), - [1998] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2893), - [2000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), - [2002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), - [2004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [2006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [2008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [2010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), - [2012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [2014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [2016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [2018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [2020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [2022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [2024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [2026] = {.entry = {.count = 1, .reusable = false}}, SHIFT(334), - [2028] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2446), - [2030] = {.entry = {.count = 1, .reusable = false}}, SHIFT(484), - [2032] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1827), - [2034] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1997), - [2036] = {.entry = {.count = 1, .reusable = false}}, SHIFT(367), - [2038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), - [2040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), - [2042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [2044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [2046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [2048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [2050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [2052] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), - [2054] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2405), - [2056] = {.entry = {.count = 1, .reusable = false}}, SHIFT(500), - [2058] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1808), - [2060] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1959), - [2062] = {.entry = {.count = 1, .reusable = false}}, SHIFT(365), - [2064] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_of, 2), - [2066] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 5, .production_id = 35), - [2068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 6, .production_id = 35), - [2070] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333), - [2072] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2486), - [2074] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1813), - [2076] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1969), - [2078] = {.entry = {.count = 1, .reusable = false}}, SHIFT(359), - [2080] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_tuning, 1), - [2082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3237), - [2084] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3237), - [2086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3232), - [2088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), - [2090] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_tuning, 2), - [2092] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1569), - [2095] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1568), - [2098] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1596), - [2101] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), - [2103] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_variable_definition_repeat1, 2), - [2105] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3241), - [2107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3241), - [2109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3226), - [2111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1334), - [2113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1233), - [2115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1146), - [2117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(836), - [2119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1821), - [2121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), - [2123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1804), - [2125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1817), - [2127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1816), - [2129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1815), - [2131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1836), - [2133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [2135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(822), - [2137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [2139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(778), - [2141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), - [2143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), - [2145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(305), - [2147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(819), - [2149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(659), - [2151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), - [2153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(646), - [2155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), - [2157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(803), - [2159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), - [2161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), - [2163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), - [2165] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(408), - [2168] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(1533), - [2171] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(3185), - [2174] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(2664), - [2177] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(2795), - [2180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(523), - [2182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), - [2184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(532), - [2186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), - [2188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(652), - [2190] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_column, 1, .production_id = 22), - [2192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), - [2194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1925), - [2196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3254), - [2198] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_access_tuning, 1), - [2200] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_access_tuning, 1), - [2202] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scope_tuning, 1), - [2204] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scope_tuning, 1), - [2206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), REDUCE(aux_sym_buffer_definition_repeat1, 1), - [2209] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), - [2211] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_variable_definition_repeat1, 1), - [2213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 1), - [2215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), - [2217] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), SHIFT_REPEAT(1533), - [2220] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), SHIFT_REPEAT(3185), - [2223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pre_tuning, 1), - [2225] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 1, .production_id = 19), - [2227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2842), - [2229] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1821), - [2232] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), - [2234] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1804), - [2237] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1817), - [2240] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1816), - [2243] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1815), - [2246] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 15), SHIFT_REPEAT(1836), - [2249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [2251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), - [2253] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primitive_type, 1), - [2255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2, .production_id = 19), - [2257] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 2), - [2259] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 2), SHIFT_REPEAT(2842), - [2262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), - [2264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), - [2266] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 4, .production_id = 44), - [2268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), - [2270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1984), - [2272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2211), - [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), - [2276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1818), - [2278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2799), - [2280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2684), - [2282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3152), - [2284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3151), - [2286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1028), - [2288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2683), - [2290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1243), - [2292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2651), - [2294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1030), - [2296] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3254), - [2299] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1609), - [2301] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 3), - [2303] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2543), - [2305] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 2), - [2307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_serialization_tuning, 1), - [2309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_serialization_tuning, 1), - [2311] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 1), - [2313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3242), - [2315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3243), - [2317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1017), - [2319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2848), - [2321] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), SHIFT_REPEAT(1569), - [2324] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), SHIFT_REPEAT(1568), - [2327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), - [2329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), - [2331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), - [2333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3231), - [2335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3230), - [2337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1284), - [2339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2688), - [2341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), - [2343] = {.entry = {.count = 1, .reusable = false}}, SHIFT(294), - [2345] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2146), - [2347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3275), - [2349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1211), - [2351] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2616), - [2353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), - [2355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_and, 2, .production_id = 6), - [2357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), - [2359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), - [2361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_first, 4, .production_id = 17), - [2363] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 4), - [2365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), - [2367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2559), - [2369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1313), - [2371] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_and, 4, .production_id = 17), - [2373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), - [2375] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [2377] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [2379] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), - [2381] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), - [2383] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(476), - [2386] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(1984), - [2389] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(2211), - [2392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), - [2394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 5, .production_id = 44), - [2396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 5), - [2398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [2400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), - [2402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), - [2404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_first, 2, .production_id = 6), - [2406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [2408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_implements, 2), - [2410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1830), - [2412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 1, .production_id = 19), - [2414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1036), - [2416] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1566), - [2418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_clause, 3), - [2420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), - [2422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(568), - [2424] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), SHIFT_REPEAT(1566), - [2427] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), - [2429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), - [2431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(647), - [2433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3280), - [2435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(98), - [2437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(399), - [2439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2311), - [2441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3279), - [2443] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 7, .production_id = 35), - [2445] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3275), - [2448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(349), - [2450] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 1), - [2452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_implements_repeat1, 2), - [2454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_clause, 2), - [2456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), - [2458] = {.entry = {.count = 1, .reusable = false}}, SHIFT(223), - [2460] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3251), - [2462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1006), - [2464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), - [2466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1807), - [2468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2, .production_id = 14), - [2470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), - [2472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), - [2474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1131), - [2476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), - [2478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_implements, 3), - [2480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1364), - [2482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), - [2484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1177), - [2486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1352), - [2488] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_implements_repeat1, 2), SHIFT_REPEAT(1830), - [2491] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 1), - [2493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1126), - [2495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), - [2497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1381), - [2499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), - [2501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1123), - [2503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1204), - [2505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1333), - [2507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1329), - [2509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), - [2511] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1328), - [2513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), - [2515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1164), - [2517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), - [2519] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_tuning, 2), - [2521] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_tuning, 2), - [2523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1312), - [2525] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), - [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), - [2529] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), SHIFT_REPEAT(1818), - [2532] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), SHIFT_REPEAT(2684), - [2535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), - [2537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1282), - [2539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), - [2541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1095), - [2543] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), - [2545] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), SHIFT_REPEAT(390), - [2548] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), SHIFT_REPEAT(1807), - [2551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1331), - [2553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), - [2555] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1535), - [2557] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3271), - [2559] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2150), - [2561] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2244), - [2563] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3315), - [2565] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2176), - [2567] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3263), - [2569] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 2), - [2571] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 2), SHIFT_REPEAT(2543), - [2574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1285), - [2576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2545), - [2578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2083), - [2580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2686), - [2582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2687), - [2584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1025), - [2586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2890), - [2588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2847), - [2590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1207), - [2592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2558), - [2594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2901), - [2596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2028), - [2598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), - [2600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 4), - [2602] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2150), - [2605] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2244), - [2608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), - [2610] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2176), - [2613] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(3263), - [2616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1363), - [2618] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1542), - [2620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1336), - [2622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2710), - [2624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2711), - [2626] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), SHIFT_REPEAT(1609), - [2629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2004), - [2631] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3317), - [2633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 1), - [2635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_temp_table_definition_repeat1, 1), - [2637] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), - [2639] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), - [2641] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), - [2643] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [2645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_tuning, 1), - [2647] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), - [2649] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1550), - [2651] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 1), - [2653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 1), - [2655] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1544), - [2657] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [2659] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2941), - [2661] = {.entry = {.count = 1, .reusable = true}}, SHIFT(422), - [2663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abstract, 1), - [2665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_widget_pool, 1), - [2667] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1687), - [2669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_tuning, 1), - [2671] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_tuning, 1), - [2673] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [2675] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [2677] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_serializable, 1), - [2679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), - [2681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), - [2683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1023), - [2685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2964), - [2687] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2783), - [2689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1393), - [2691] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2740), - [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), - [2695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), - [2697] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), SHIFT_REPEAT(3146), - [2700] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), SHIFT_REPEAT(1970), - [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1710), - [2705] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1366), - [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2728), - [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), - [2711] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat1, 2), SHIFT_REPEAT(501), - [2714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1324), - [2716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2928), - [2718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_final, 1), - [2720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2646), - [2722] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1107), - [2724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [2726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1370), - [2728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), - [2730] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 1), - [2732] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3041), - [2734] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2878), - [2736] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3036), - [2738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1058), - [2740] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), SHIFT_REPEAT(1993), - [2743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), - [2745] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), SHIFT_REPEAT(3002), - [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1061), - [2750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1332), - [2752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1391), - [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1392), - [2758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_body, 1), - [2760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), - [2762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [2766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1993), - [2768] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_phrase, 2), - [2770] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3002), - [2772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1022), - [2774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), - [2776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [2778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), - [2780] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), SHIFT_REPEAT(2545), - [2783] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), SHIFT_REPEAT(2083), - [2786] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 1), - [2788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2697), - [2790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1322), - [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1293), - [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1246), - [2798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), - [2800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1087), - [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1088), - [2806] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_column, 2, .production_id = 22), - [2808] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_tuning, 2), - [2810] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_order, 1), - [2812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1245), - [2814] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), - [2816] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), SHIFT_REPEAT(3152), - [2819] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), SHIFT_REPEAT(3151), - [2822] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_phrase, 3), - [2824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), - [2826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1237), - [2828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [2830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [2832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3196), - [2834] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 2), - [2836] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 2), SHIFT_REPEAT(422), - [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), - [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2311), - [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), - [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [2847] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2773), - [2849] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2776), - [2851] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2778), - [2853] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 1), - [2855] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [2857] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [2859] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [2861] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), - [2863] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1566), - [2865] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 2), SHIFT_REPEAT(2990), - [2868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 2), - [2870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [2872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [2874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [2876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [2878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2091), - [2880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2113), - [2882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [2884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [2886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2859), - [2888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2253), - [2890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2122), - [2892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 1), - [2894] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2979), - [2896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 8, .production_id = 35), - [2898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), - [2900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), - [2902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_fields, 2), - [2904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [2906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [2908] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2990), - [2910] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1192), - [2912] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3051), - [2914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [2916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [2918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), - [2920] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1251), - [2922] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3269), - [2924] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1159), - [2926] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2992), - [2928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [2930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [2932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1116), - [2934] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3182), - [2936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2640), - [2938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2891), - [2940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2641), - [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2905), - [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2232), - [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2099), - [2950] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 2), - [2952] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2971), - [2954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_fields, 3), - [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2604), - [2958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2912), - [2960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2605), - [2962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2663), - [2964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2659), - [2966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2734), - [2968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), - [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [2972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2121), - [2974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2097), - [2976] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2140), - [2978] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2219), - [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2911), - [2982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2937), - [2984] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 2), SHIFT_REPEAT(2213), - [2987] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 2), - [2989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 1), - [2991] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition_tuning, 1), - [2993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), - [2995] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3178), - [2997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3179), - [2999] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2989), - [3001] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3174), - [3003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3175), - [3005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2988), - [3007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), - [3009] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), - [3011] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3294), - [3013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3293), - [3015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3292), - [3017] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), - [3019] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6, .production_id = 49), - [3021] = {.entry = {.count = 1, .reusable = false}}, SHIFT(642), - [3023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), - [3025] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3284), - [3027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3283), - [3029] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3282), - [3031] = {.entry = {.count = 1, .reusable = false}}, SHIFT(213), - [3033] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2611), - [3035] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), - [3037] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [3039] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2124), - [3041] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_error_phrase, 6, .production_id = 25), - [3043] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [3045] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6, .production_id = 25), - [3047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2800), - [3049] = {.entry = {.count = 1, .reusable = false}}, SHIFT(526), - [3051] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2328), - [3053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 6), - [3055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [3057] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2213), - [3059] = {.entry = {.count = 1, .reusable = false}}, SHIFT(521), - [3061] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 4), - [3063] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 2), - [3065] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 2), SHIFT_REPEAT(2219), - [3068] = {.entry = {.count = 1, .reusable = false}}, SHIFT(637), - [3070] = {.entry = {.count = 1, .reusable = false}}, SHIFT(801), - [3072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), - [3074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3126), - [3076] = {.entry = {.count = 1, .reusable = false}}, SHIFT(633), - [3078] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), - [3080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [3082] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 5), - [3084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2804), - [3086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2172), - [3088] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 9, .production_id = 35), - [3090] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2089), - [3092] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_error_phrase, 5), - [3094] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 5), - [3096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), - [3098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3203), - [3100] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 7, .production_id = 53), - [3102] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 7, .production_id = 25), - [3104] = {.entry = {.count = 1, .reusable = false}}, SHIFT(786), - [3106] = {.entry = {.count = 1, .reusable = false}}, SHIFT(827), - [3108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2104), - [3110] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2458), - [3112] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 5), - [3114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2906), - [3116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2538), - [3118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(773), - [3120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(815), - [3122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2866), - [3124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2932), - [3126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition_tuning, 2), - [3128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [3130] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 1), - [3132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(18), - [3134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2681), - [3136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [3138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(53), - [3140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2856), - [3142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(281), - [3144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(280), - [3146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [3148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1, .production_id = 2), - [3150] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1, .production_id = 2), - [3152] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1), - [3154] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1), - [3156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [3158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(279), - [3160] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1, .production_id = 3), - [3162] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1, .production_id = 3), - [3164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(278), - [3166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [3168] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_include_repeat1, 1), - [3170] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 1), - [3172] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat2, 2), SHIFT_REPEAT(3081), - [3175] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat2, 2), - [3177] = {.entry = {.count = 1, .reusable = false}}, SHIFT(72), - [3179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2790), - [3181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [3183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2129), - [3185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2939), - [3187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [3189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(531), - [3191] = {.entry = {.count = 1, .reusable = false}}, SHIFT(536), - [3193] = {.entry = {.count = 1, .reusable = false}}, SHIFT(826), - [3195] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6), - [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2863), - [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2318), - [3201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2314), - [3203] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 4), - [3205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(106), - [3207] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2922), - [3209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), - [3211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2173), - [3213] = {.entry = {.count = 1, .reusable = false}}, SHIFT(807), - [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [3217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [3221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2934), - [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3247), - [3225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2670), - [3227] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3247), - [3229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), - [3231] = {.entry = {.count = 1, .reusable = false}}, SHIFT(752), - [3233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3124), - [3235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), - [3237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), - [3239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__function_call_arguments_repeat1, 2), - [3241] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_call_arguments_repeat1, 2), SHIFT_REPEAT(328), - [3244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [3246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [3248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [3250] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_call_arguments, 1), - [3252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), - [3254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3073), - [3256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1682), - [3258] = {.entry = {.count = 1, .reusable = false}}, SHIFT(287), - [3260] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3228), - [3262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(628), - [3264] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 1), - [3266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), - [3268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [3270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2942), - [3272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3160), - [3274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2907), - [3276] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3160), - [3278] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 1), - [3280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1010), - [3282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), - [3284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), - [3286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [3288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), - [3290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [3292] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_branch_body, 1), - [3294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2124), - [3296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [3298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_statement_repeat1, 2), SHIFT_REPEAT(2102), - [3301] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_statement_repeat1, 2), - [3303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2927), - [3305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2054), - [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), - [3309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_when_branch, 4, .production_id = 50), - [3311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), - [3313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), - [3315] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3132), - [3317] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2775), - [3319] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3132), - [3321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), - [3323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [3325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), - [3327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), - [3329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2089), - [3331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [3333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), - [3337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [3339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2667), - [3341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [3343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), - [3345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), - [3347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3169), - [3349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2874), - [3351] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3169), - [3353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), - [3355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 1), - [3357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2916), - [3359] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2003), - [3361] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 1), - [3363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [3365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2666), - [3367] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), - [3369] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), SHIFT_REPEAT(1682), - [3372] = {.entry = {.count = 1, .reusable = false}}, SHIFT(691), - [3374] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3010), - [3376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), - [3378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [3380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2738), - [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3190), - [3388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3210), - [3390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2594), - [3392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2002), - [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2655), - [3396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 5, .production_id = 36), - [3398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 5), - [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2910), - [3402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_stop_phrase, 5), - [3404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2951), - [3406] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 7), - [3408] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2223), - [3410] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2785), - [3412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 7, .production_id = 54), - [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2938), - [3416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [3418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2828), - [3420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_statement_repeat1, 2), - [3422] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_statement_repeat1, 2), SHIFT_REPEAT(2003), - [3425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3214), - [3427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2636), - [3429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), - [3431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2844), - [3433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [3435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), - [3437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [3439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), - [3441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [3443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2633), - [3445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2370), - [3447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2577), - [3449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3056), - [3451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), - [3453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(618), - [3455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3040), - [3457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [3459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), - [3461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(527), - [3463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1133), - [3465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2631), - [3467] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2466), - [3469] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2689), - [3471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2609), - [3473] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1330), - [3475] = {.entry = {.count = 1, .reusable = false}}, SHIFT(364), - [3477] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3253), - [3479] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), - [3481] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), - [3483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 6, .production_id = 49), - [3485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 6), - [3487] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1335), - [3489] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3046), - [3491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3261), - [3493] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2569), - [3495] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3261), - [3497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2600), - [3499] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [3501] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), - [3503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2596), - [3505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [3507] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2589), - [3509] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1283), - [3511] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 1), - [3513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [3515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [3517] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3024), - [3519] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2494), - [3521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2650), - [3523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [3525] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2429), - [3527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2853), - [3529] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2220), - [3531] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2796), - [3533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), - [3535] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [3537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [3539] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [3541] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2565), - [3543] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_fields_repeat1, 2), SHIFT_REPEAT(2927), - [3546] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_query_fields_repeat1, 2), - [3548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1127), - [3550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2935), - [3552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_stop_phrase, 6, .production_id = 25), - [3554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1923), - [3556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1369), - [3558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), - [3560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [3562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [3564] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_call_arguments, 2), - [3566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), - [3568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2994), - [3570] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2582), - [3572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2994), - [3574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2312), - [3576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_aggregate, 1), - [3578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1434), - [3580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1434), - [3582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3267), - [3584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3273), - [3586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2059), - [3588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2278), - [3590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(849), - [3592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3194), - [3594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [3596] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1436), - [3598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), - [3600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1540), - [3602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3163), - [3604] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3163), - [3606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), - [3608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), - [3610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3158), - [3612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), - [3614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3157), - [3616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), - [3618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3155), - [3620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3221), - [3622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [3624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2259), - [3626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(373), - [3628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3244), - [3630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1541), - [3632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3191), - [3634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3011), - [3636] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3011), - [3638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3108), - [3640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2248), - [3642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3014), - [3644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), - [3646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3015), - [3648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(841), - [3650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), - [3652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3019), - [3654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3020), - [3656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2164), - [3658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2630), - [3660] = {.entry = {.count = 1, .reusable = true}}, SHIFT(847), - [3662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2289), - [3664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(840), - [3666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3022), - [3668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2668), - [3670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3225), - [3672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(845), - [3674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [3676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2198), - [3678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1782), - [3680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2493), - [3682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1822), - [3684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3183), - [3686] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1992), - [3688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3181), - [3690] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2133), - [3692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(842), - [3694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(848), - [3696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2228), - [3698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2117), - [3700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2729), - [3702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3039), - [3704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2475), - [3706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1819), - [3708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2447), - [3710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1775), - [3712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), - [3714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3199), - [3716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(619), - [3718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(843), - [3720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3121), - [3722] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1228), - [3724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3139), - [3726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), - [3728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3217), - [3730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), - [3732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3122), - [3734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1519), - [3736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1374), - [3738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3117), - [3740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(846), - [3742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(844), - [3744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2532), - [3746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3184), - [3748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2056), - [3750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3270), - [3752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3270), - [3754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_argument_with_mode, 2), - [3756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(366), - [3758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), - [3760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1791), - [3762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1754), - [3764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1777), - [3766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2544), - [3768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), - [3770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1437), - [3772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3106), - [3774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2440), - [3776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1806), - [3778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3061), - [3780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2069), - [3782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3100), - [3784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2171), - [3786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), - [3788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3098), - [3790] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2163), - [3792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(751), - [3794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), - [3796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3089), - [3798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3112), - [3800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1040), - [3802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3088), - [3804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3079), - [3806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3114), - [3808] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3114), - [3810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3078), - [3812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1037), - [3814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3077), - [3816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2490), - [3818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1018), - [3820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3074), - [3822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [3824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(729), - [3826] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1684), - [3828] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3063), - [3830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2537), - [3832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1445), - [3834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2843), - [3836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(596), - [3838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1789), - [3840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(978), - [3842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2316), - [3844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3005), - [3846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), - [3848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3091), - [3850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1077), - [3852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3033), - [3854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1081), - [3856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3032), - [3858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [3860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), - [3862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3030), - [3864] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat2, 1), - [3866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), - [3868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3087), - [3870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1382), - [3872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3086), - [3874] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1614), - [3876] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3017), - [3878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1587), - [3880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [3882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1794), - [3884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2421), - [3886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1354), - [3888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3065), - [3890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), - [3892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3062), - [3894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [3896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), - [3898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3060), - [3900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2170), - [3902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2908), - [3904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2462), - [3906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3195), - [3908] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3195), - [3910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1307), - [3912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3054), - [3914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1306), - [3916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3053), - [3918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1305), - [3920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3052), - [3922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), - [3924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1165), - [3926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3004), - [3928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1167), - [3930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3003), - [3932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), - [3934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3001), - [3936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), - [3938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3045), - [3940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), - [3942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3043), - [3944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1265), - [3946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), - [3948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3038), - [3950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), - [3952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2125), - [3954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2933), - [3956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3140), - [3958] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3140), - [3960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 6), - [3962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), - [3964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3025), - [3966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 6, .production_id = 49), - [3968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2326), - [3970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3023), - [3972] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1227), - [3974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [3976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1153), - [3978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2977), - [3980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [3982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), - [3984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_fields_repeat1, 1), - [3986] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_query_fields_repeat1, 1), - [3988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2458), - [3990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 7, .production_id = 25), - [3992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1218), - [3994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3090), - [3996] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 7, .production_id = 53), - [3998] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 3), - [4000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2328), - [4002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3144), - [4004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2314), - [4006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3044), - [4008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3031), - [4010] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 10, .production_id = 35), - [4012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), - [4014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1048), - [4016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3143), - [4018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1157), - [4020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2978), - [4022] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 4), - [4024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), - [4026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(825), - [4028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2976), - [4030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2107), - [4032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [4034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [4036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [4038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2116), - [4040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1047), - [4042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2972), - [4044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [4046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [4048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [4050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(738), - [4052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [4054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), - [4056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), - [4058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1186), - [4060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), - [4062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), - [4064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), - [4066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), - [4068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), - [4070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), - [4072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [4074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [4076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), - [4078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2959), - [4080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1212), - [4082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2049), - [4084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1173), - [4086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1174), - [4088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), - [4090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [4092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1160), - [4094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2727), - [4096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), - [4098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [4100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1241), - [4102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), - [4104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2991), - [4106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1620), - [4108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), - [4110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1249), - [4112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), - [4114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1266), - [4116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), - [4118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1179), - [4120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2967), - [4122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(553), - [4124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_otherwise_branch, 2, .production_id = 39), - [4126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1166), - [4128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), - [4130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1162), - [4132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1155), - [4134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3006), - [4136] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter_mode, 1), - [4138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), - [4140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), - [4142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2654), - [4144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), - [4146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), - [4148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1311), - [4150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1314), - [4152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1315), - [4154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [4156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), - [4158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), - [4160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1347), - [4162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), - [4164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), - [4166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), - [4168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1378), - [4170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2074), - [4172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1379), - [4174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3018), - [4176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [4178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [4180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [4182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), - [4184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [4186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [4188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [4190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1105), - [4192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1104), - [4194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_body, 2), - [4196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1091), - [4198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1090), - [4200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1089), - [4202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [4204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1887), - [4206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [4208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2885), - [4210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [4212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2879), - [4214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1338), - [4216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1071), - [4218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1288), - [4220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), - [4222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [4224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), - [4226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [4228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [4230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), - [4232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), - [4234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2128), - [4236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2130), - [4238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [4240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(915), - [4242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [4244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), - [4246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1785), - [4248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1720), - [4250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), - [4252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), - [4254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), - [4256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [4258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), - [4260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), - [4262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2120), - [4264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), - [4266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(565), - [4268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [4270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1033), - [4272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1034), - [4274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2791), - [4276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), - [4278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(428), - [4280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2826), - [4282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1856), - [4284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(923), - [4286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(924), - [4288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2161), - [4290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(779), - [4292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(784), - [4294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(793), - [4296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), - [4298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), - [4300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(930), - [4302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), - [4304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(833), - [4306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2825), - [4308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1079), - [4310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1073), - [4312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2517), - [4314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2029), - [4316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3105), - [4318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2511), - [4320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2840), - [4322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1784), - [4324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1594), - [4326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2797), - [4328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), - [4330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [4332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), - [4334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), - [4336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1183), - [4338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1194), - [4340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [4342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(823), - [4344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2534), - [4346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2529), - [4348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(515), - [4350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), - [4352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), - [4354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(456), - [4356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2576), - [4358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(794), - [4360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3229), - [4362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), - [4364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2855), - [4366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2093), - [4368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2587), - [4370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2588), - [4372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2857), - [4374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [4376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2592), - [4378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2593), - [4380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2786), - [4382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2080), - [4384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1339), - [4386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2047), - [4388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2040), - [4390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1537), - [4392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), - [4394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(643), - [4396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2505), - [4398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3216), - [4400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2629), - [4402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2501), - [4404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), - [4406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), - [4408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1798), - [4410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), - [4412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1743), - [4414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2444), - [4416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3197), - [4418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), - [4420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), - [4422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [4424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [4426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2877), - [4428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2723), - [4430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2160), - [4432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), - [4434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2720), - [4436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [4438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1783), - [4440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1767), - [4442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2174), - [4444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), - [4446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2887), - [4448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [4450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2139), - [4452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [4454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1607), - [4456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2904), - [4458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1814), - [4460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3147), - [4462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3148), - [4464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1588), - [4466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2661), - [4468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3188), - [4470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3189), - [4472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(376), - [4474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2699), - [4476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1052), - [4478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3150), - [4480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3198), - [4482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2653), - [4484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3200), - [4486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3201), - [4488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1117), - [4490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), - [4492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1897), - [4494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(641), - [4496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [4498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3156), - [4500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), - [4502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [4504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2675), - [4506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1643), - [4508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2671), - [4510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(304), - [4512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_mode, 1), - [4514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), - [4516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), - [4518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), - [4520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), - [4522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3165), - [4524] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3314), - [4526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1007), - [4528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2560), - [4530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2327), - [4532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1116), - [4534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(638), - [4536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__find_type, 1), - [4538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1825), - [4540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1961), - [4542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1712), - [4544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1724), - [4546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), - [4548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), - [4550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), - [4552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), - [4554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(442), - [4556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1108), - [4558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2583), - [4560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2578), - [4562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2999), - [4564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3238), - [4566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3239), - [4568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1589), - [4570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3145), - [4572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2575), - [4574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3249), - [4576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1134), - [4578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2574), - [4580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2573), - [4582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2137), - [4584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1610), - [4586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3316), - [4588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), - [4590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3309), - [4592] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3297), - [4594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1287), - [4596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), - [4598] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [4600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1787), - [4602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), - [4604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3268), - [4606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3240), - [4608] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3272), - [4610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2407), - [4612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(625), - [4614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2567), - [4616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2566), - [4618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1779), - [4620] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2), - [4622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 3), - [4624] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3), - [4626] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 4), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(348), + [13] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2367), + [15] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1477), + [17] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1547), + [19] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2498), + [21] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2494), + [23] = {.entry = {.count = 1, .reusable = false}}, SHIFT(491), + [25] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2097), + [27] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1657), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3794), + [31] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3791), + [35] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2096), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2086), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [41] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2964), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3784), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2020), + [47] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2226), + [49] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3780), + [51] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3779), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(488), + [55] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2975), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3684), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3808), + [61] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_qualified_name, 2), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3807), + [65] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_qualified_name, 2), + [67] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3627), + [69] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_qualified_name_repeat1, 2), + [71] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), + [73] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3627), + [76] = {.entry = {.count = 1, .reusable = false}}, SHIFT(351), + [78] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2959), + [80] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2425), + [82] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1480), + [84] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1548), + [86] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2522), + [88] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2424), + [90] = {.entry = {.count = 1, .reusable = false}}, SHIFT(469), + [92] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2094), + [94] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1689), + [96] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3685), + [98] = {.entry = {.count = 1, .reusable = false}}, SHIFT(382), + [100] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3771), + [102] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2063), + [104] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2065), + [106] = {.entry = {.count = 1, .reusable = false}}, SHIFT(544), + [108] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3039), + [110] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3686), + [112] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2025), + [114] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2231), + [116] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3809), + [118] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3687), + [120] = {.entry = {.count = 1, .reusable = false}}, SHIFT(515), + [122] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3007), + [124] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3177), + [126] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [128] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2889), + [130] = {.entry = {.count = 1, .reusable = false}}, SHIFT(308), + [132] = {.entry = {.count = 1, .reusable = false}}, SHIFT(307), + [134] = {.entry = {.count = 1, .reusable = false}}, SHIFT(299), + [136] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2475), + [138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2474), + [140] = {.entry = {.count = 1, .reusable = false}}, SHIFT(443), + [142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(302), + [144] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1911), + [146] = {.entry = {.count = 1, .reusable = false}}, SHIFT(408), + [148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(409), + [150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(410), + [152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), + [154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2876), + [156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3038), + [158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3668), + [160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(492), + [162] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3689), + [164] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3209), + [166] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1800), + [168] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2540), + [170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3010), + [172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3119), + [174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3568), + [176] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3658), + [178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3503), + [180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3410), + [182] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3599), + [184] = {.entry = {.count = 1, .reusable = false}}, SHIFT(566), + [186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(473), + [188] = {.entry = {.count = 1, .reusable = false}}, SHIFT(542), + [190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(419), + [192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(392), + [194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2530), + [196] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3009), + [198] = {.entry = {.count = 1, .reusable = false}}, SHIFT(489), + [200] = {.entry = {.count = 1, .reusable = false}}, SHIFT(534), + [202] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1644), + [204] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3399), + [206] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3337), + [208] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2984), + [210] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1811), + [212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3664), + [214] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), + [216] = {.entry = {.count = 1, .reusable = false}}, SHIFT(328), + [218] = {.entry = {.count = 1, .reusable = false}}, SHIFT(905), + [220] = {.entry = {.count = 1, .reusable = false}}, SHIFT(879), + [222] = {.entry = {.count = 1, .reusable = false}}, SHIFT(886), + [224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), + [226] = {.entry = {.count = 1, .reusable = false}}, SHIFT(656), + [228] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), + [230] = {.entry = {.count = 1, .reusable = false}}, SHIFT(659), + [232] = {.entry = {.count = 1, .reusable = false}}, SHIFT(564), + [234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(911), + [236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2953), + [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3295), + [240] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3216), + [242] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3153), + [244] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3276), + [246] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3324), + [248] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3060), + [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2991), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3109), + [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3152), + [256] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_source_code, 1), + [258] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_code_repeat1, 2), + [260] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(348), + [263] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2367), + [266] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1477), + [269] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1547), + [272] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2498), + [275] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2494), + [278] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(491), + [281] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2097), + [284] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1657), + [287] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3794), + [290] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(381), + [293] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3791), + [296] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2096), + [299] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2086), + [302] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(391), + [305] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2964), + [308] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3784), + [311] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2020), + [314] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2226), + [317] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3780), + [320] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3779), + [323] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(488), + [326] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2975), + [329] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_body, 1), + [331] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(351), + [334] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), + [336] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2425), + [339] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1480), + [342] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1548), + [345] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2522), + [348] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2424), + [351] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(469), + [354] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2094), + [357] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(1689), + [360] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3685), + [363] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(382), + [366] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3771), + [369] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2063), + [372] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2065), + [375] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(544), + [378] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3039), + [381] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3686), + [384] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2025), + [387] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(2231), + [390] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3809), + [393] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3687), + [396] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(515), + [399] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 2), SHIFT_REPEAT(3007), + [402] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_single_quoted_string, 2), + [404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_single_quoted_string, 2), + [406] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_string, 2), + [408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_string, 2), + [410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__string_literal, 1), + [412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__string_literal, 1), + [414] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_single_quoted_string, 3), + [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_single_quoted_string, 3), + [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_double_quoted_string, 3), + [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_double_quoted_string, 3), + [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_number_literal, 1), + [424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_number_literal, 1), + [426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3619), + [428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__decimal_literal, 3), + [430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__decimal_literal, 3), + [432] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 3, .production_id = 5), + [434] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 3, .production_id = 5), + [436] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call, 4, .production_id = 5), + [438] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call, 4, .production_id = 5), + [440] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1893), + [442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__binary_expression, 1), + [444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__binary_expression, 1), + [446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_expression, 4, .production_id = 15), + [448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_expression, 4, .production_id = 15), + [450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_boolean_literal, 1), + [452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_boolean_literal, 1), + [454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__expression, 1), + [456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__expression, 1), + [458] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 4), + [460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 4), + [462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_parenthesized_expression, 3), + [464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parenthesized_expression, 3), + [466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 7, .production_id = 39), + [468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 7, .production_id = 39), + [470] = {.entry = {.count = 1, .reusable = false}}, SHIFT(366), + [472] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), + [474] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), + [476] = {.entry = {.count = 1, .reusable = false}}, SHIFT(769), + [478] = {.entry = {.count = 1, .reusable = false}}, SHIFT(427), + [480] = {.entry = {.count = 1, .reusable = false}}, SHIFT(774), + [482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 27), + [484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 27), + [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 39), + [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 39), + [490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 6, .production_id = 26), + [492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 6, .production_id = 26), + [494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 4, .production_id = 16), + [496] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 4, .production_id = 16), + [498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 3), + [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 3), + [502] = {.entry = {.count = 1, .reusable = false}}, SHIFT(485), + [504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_available_expression, 2), + [506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_available_expression, 2), + [508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 6), + [510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 6), + [512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 27), + [514] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 27), + [516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 16), + [518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 16), + [520] = {.entry = {.count = 1, .reusable = false}}, SHIFT(860), + [522] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_can_find_expression, 5, .production_id = 26), + [524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_can_find_expression, 5, .production_id = 26), + [526] = {.entry = {.count = 1, .reusable = false}}, SHIFT(858), + [528] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2035), + [530] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), + [532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__unary_minus_expressions, 1), + [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__unary_minus_expressions, 1), + [536] = {.entry = {.count = 1, .reusable = false}}, SHIFT(516), + [538] = {.entry = {.count = 1, .reusable = false}}, SHIFT(898), + [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 5), + [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 5), + [544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_expression, 2, .production_id = 6), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_expression, 2, .production_id = 6), + [548] = {.entry = {.count = 1, .reusable = false}}, SHIFT(902), + [550] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2), + [552] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2), + [554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3102), + [558] = {.entry = {.count = 1, .reusable = false}}, SHIFT(363), + [560] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2520), + [562] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2809), + [564] = {.entry = {.count = 1, .reusable = false}}, SHIFT(563), + [566] = {.entry = {.count = 1, .reusable = false}}, SHIFT(571), + [568] = {.entry = {.count = 1, .reusable = false}}, SHIFT(532), + [570] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2488), + [572] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2484), + [574] = {.entry = {.count = 1, .reusable = false}}, SHIFT(311), + [576] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1933), + [578] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), + [580] = {.entry = {.count = 1, .reusable = false}}, SHIFT(502), + [582] = {.entry = {.count = 1, .reusable = false}}, SHIFT(501), + [584] = {.entry = {.count = 1, .reusable = false}}, SHIFT(500), + [586] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2523), + [588] = {.entry = {.count = 1, .reusable = false}}, SHIFT(498), + [590] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2995), + [592] = {.entry = {.count = 1, .reusable = false}}, SHIFT(490), + [594] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2575), + [596] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3736), + [598] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1824), + [600] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2526), + [602] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1464), + [604] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1463), + [606] = {.entry = {.count = 1, .reusable = false}}, SHIFT(937), + [608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), + [610] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), + [612] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(3102), + [615] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1393), + [617] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1402), + [619] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1017), + [621] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_access, 2, .production_id = 4), + [623] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_access, 2, .production_id = 4), + [625] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), + [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ternary_expression, 6, .production_id = 38), + [629] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1504), + [631] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1503), + [633] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1501), + [635] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1500), + [637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 3), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 1), + [641] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_locked_expression, 2), + [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_current_changed_expression, 2), + [645] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_ambiguous_expression, 2), + [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_expression, 3), + [649] = {.entry = {.count = 1, .reusable = false}}, SHIFT(317), + [651] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3029), + [653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3727), + [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_expression, 3), + [657] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 10), + [659] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 10), + [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 9), + [663] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 9), + [665] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 3), + [669] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1023), + [671] = {.entry = {.count = 1, .reusable = false}}, SHIFT(434), + [673] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2703), + [675] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(363), + [678] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2520), + [681] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), + [683] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(563), + [686] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(571), + [689] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(532), + [692] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2488), + [695] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2484), + [698] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(434), + [701] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(1933), + [704] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(508), + [707] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(502), + [710] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(501), + [713] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(500), + [716] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2523), + [719] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2995), + [722] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(490), + [725] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(3736), + [728] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(1824), + [731] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_abl_statement_repeat1, 2), SHIFT_REPEAT(2526), + [734] = {.entry = {.count = 1, .reusable = false}}, SHIFT(944), + [736] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1120), + [738] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1434), + [740] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1018), + [742] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1105), + [744] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1407), + [746] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(3029), + [749] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3727), + [752] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2748), + [754] = {.entry = {.count = 1, .reusable = false}}, SHIFT(938), + [756] = {.entry = {.count = 1, .reusable = false}}, SHIFT(672), + [758] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1914), + [760] = {.entry = {.count = 1, .reusable = false}}, SHIFT(404), + [762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(403), + [764] = {.entry = {.count = 1, .reusable = false}}, SHIFT(402), + [766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(400), + [768] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2542), + [770] = {.entry = {.count = 1, .reusable = false}}, SHIFT(428), + [772] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1797), + [774] = {.entry = {.count = 1, .reusable = false}}, SHIFT(670), + [776] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2716), + [778] = {.entry = {.count = 1, .reusable = false}}, SHIFT(825), + [780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(824), + [782] = {.entry = {.count = 1, .reusable = false}}, SHIFT(773), + [784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2473), + [786] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2491), + [788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(452), + [790] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1922), + [792] = {.entry = {.count = 1, .reusable = false}}, SHIFT(412), + [794] = {.entry = {.count = 1, .reusable = false}}, SHIFT(413), + [796] = {.entry = {.count = 1, .reusable = false}}, SHIFT(414), + [798] = {.entry = {.count = 1, .reusable = false}}, SHIFT(415), + [800] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2694), + [802] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3013), + [804] = {.entry = {.count = 1, .reusable = false}}, SHIFT(436), + [806] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3728), + [808] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1845), + [810] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2543), + [812] = {.entry = {.count = 1, .reusable = false}}, SHIFT(719), + [814] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1943), + [816] = {.entry = {.count = 1, .reusable = false}}, SHIFT(471), + [818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(468), + [820] = {.entry = {.count = 1, .reusable = false}}, SHIFT(456), + [822] = {.entry = {.count = 1, .reusable = false}}, SHIFT(451), + [824] = {.entry = {.count = 1, .reusable = false}}, SHIFT(421), + [826] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1848), + [828] = {.entry = {.count = 1, .reusable = false}}, SHIFT(702), + [830] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2640), + [832] = {.entry = {.count = 1, .reusable = false}}, SHIFT(923), + [834] = {.entry = {.count = 1, .reusable = false}}, SHIFT(924), + [836] = {.entry = {.count = 1, .reusable = false}}, SHIFT(868), + [838] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2459), + [840] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2472), + [842] = {.entry = {.count = 1, .reusable = false}}, SHIFT(454), + [844] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1927), + [846] = {.entry = {.count = 1, .reusable = false}}, SHIFT(429), + [848] = {.entry = {.count = 1, .reusable = false}}, SHIFT(430), + [850] = {.entry = {.count = 1, .reusable = false}}, SHIFT(446), + [852] = {.entry = {.count = 1, .reusable = false}}, SHIFT(447), + [854] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2824), + [856] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3001), + [858] = {.entry = {.count = 1, .reusable = false}}, SHIFT(495), + [860] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3734), + [862] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1823), + [864] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2696), + [866] = {.entry = {.count = 1, .reusable = false}}, SHIFT(560), + [868] = {.entry = {.count = 1, .reusable = false}}, SHIFT(679), + [870] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2538), + [872] = {.entry = {.count = 1, .reusable = false}}, SHIFT(873), + [874] = {.entry = {.count = 1, .reusable = false}}, SHIFT(874), + [876] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), + [878] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2431), + [880] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2440), + [882] = {.entry = {.count = 1, .reusable = false}}, SHIFT(459), + [884] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1898), + [886] = {.entry = {.count = 1, .reusable = false}}, SHIFT(523), + [888] = {.entry = {.count = 1, .reusable = false}}, SHIFT(522), + [890] = {.entry = {.count = 1, .reusable = false}}, SHIFT(546), + [892] = {.entry = {.count = 1, .reusable = false}}, SHIFT(545), + [894] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2902), + [896] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2993), + [898] = {.entry = {.count = 1, .reusable = false}}, SHIFT(513), + [900] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3744), + [902] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1850), + [904] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2913), + [906] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_new_expression, 4), + [908] = {.entry = {.count = 1, .reusable = false}}, SHIFT(572), + [910] = {.entry = {.count = 1, .reusable = false}}, SHIFT(780), + [912] = {.entry = {.count = 1, .reusable = false}}, SHIFT(598), + [914] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2545), + [916] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), + [918] = {.entry = {.count = 1, .reusable = false}}, SHIFT(649), + [920] = {.entry = {.count = 1, .reusable = false}}, SHIFT(634), + [922] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2441), + [924] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2458), + [926] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457), + [928] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1896), + [930] = {.entry = {.count = 1, .reusable = false}}, SHIFT(518), + [932] = {.entry = {.count = 1, .reusable = false}}, SHIFT(519), + [934] = {.entry = {.count = 1, .reusable = false}}, SHIFT(521), + [936] = {.entry = {.count = 1, .reusable = false}}, SHIFT(531), + [938] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2496), + [940] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2997), + [942] = {.entry = {.count = 1, .reusable = false}}, SHIFT(510), + [944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3739), + [946] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1841), + [948] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2826), + [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [952] = {.entry = {.count = 1, .reusable = false}}, SHIFT(828), + [954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_new_expression, 4), + [956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3789), + [960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ternary_expression, 6, .production_id = 38), + [962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1503), + [964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1501), + [966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1504), + [968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1500), + [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_locked_expression, 2), + [972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_current_changed_expression, 2), + [974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 3), + [976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_ambiguous_expression, 2), + [978] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), + [980] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 3), + [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_expression, 3), + [984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_expression, 3), + [986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(553), + [988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), + [990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1644), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3399), + [994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3337), + [996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2984), + [998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(927), + [1000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [1002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [1004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), + [1006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [1008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(921), + [1010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(791), + [1012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(568), + [1014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(669), + [1016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(876), + [1018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(882), + [1020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [1022] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2956), + [1024] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_where_clause, 2, .production_id = 7), + [1026] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3507), + [1028] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3509), + [1030] = {.entry = {.count = 1, .reusable = false}}, SHIFT(496), + [1032] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1762), + [1034] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2081), + [1036] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1733), + [1038] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2075), + [1040] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2068), + [1042] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2087), + [1044] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2059), + [1046] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2041), + [1048] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2956), + [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_option, 2), + [1053] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), + [1055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3536), + [1057] = {.entry = {.count = 1, .reusable = false}}, SHIFT(647), + [1059] = {.entry = {.count = 1, .reusable = false}}, SHIFT(662), + [1061] = {.entry = {.count = 1, .reusable = false}}, SHIFT(338), + [1063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_tuning, 2), + [1065] = {.entry = {.count = 1, .reusable = false}}, SHIFT(316), + [1067] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3319), + [1069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3548), + [1071] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3064), + [1073] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3426), + [1075] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), + [1077] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2983), + [1079] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3745), + [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_on_statement_repeat1, 2), + [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_to_phrase, 3), + [1085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2736), + [1087] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3664), + [1090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(514), + [1092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3395), + [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(337), + [1098] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3035), + [1100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3793), + [1102] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 4, .production_id = 25), + [1104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(437), + [1106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3710), + [1108] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(3319), + [1111] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3426), + [1114] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3548), + [1117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat1, 2), + [1119] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3), + [1121] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(3064), + [1124] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call_argument, 1), + [1126] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_stop_after_phrase, 2), + [1128] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__while_condition, 2, .production_id = 7), + [1130] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3), + [1132] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3745), + [1135] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(2983), + [1138] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), + [1140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3662), + [1142] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), + [1144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), + [1146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [1148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1026), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(393), + [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1150), + [1158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2695), + [1160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3790), + [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(661), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1142), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(507), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(420), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(416), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(795), + [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(947), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1853), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(891), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1327), + [1186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1624), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(903), + [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1829), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [1194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(509), + [1196] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3793), + [1199] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_object_access_repeat1, 2, .production_id = 11), SHIFT_REPEAT(3035), + [1202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), + [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1135), + [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(528), + [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1628), + [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1632), + [1212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1626), + [1214] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1326), + [1216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1354), + [1218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), + [1220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(438), + [1222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [1224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), + [1226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), + [1228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1234), + [1230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), + [1232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(556), + [1234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1462), + [1236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1637), + [1238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1459), + [1240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1439), + [1242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), + [1244] = {.entry = {.count = 1, .reusable = false}}, SHIFT(878), + [1246] = {.entry = {.count = 1, .reusable = false}}, SHIFT(885), + [1248] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 2), + [1250] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), + [1252] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), SHIFT_REPEAT(1610), + [1255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 5, .production_id = 7), + [1257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 5, .production_id = 7), + [1259] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1610), + [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3422), + [1263] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_statement, 4, .production_id = 7), + [1265] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1620), + [1267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_statement, 4, .production_id = 7), + [1269] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 2), SHIFT_REPEAT(1620), + [1272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(926), + [1274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(906), + [1276] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6, .production_id = 13), + [1278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2480), + [1280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [1282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2859), + [1284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [1286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3631), + [1288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2232), + [1290] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_if_statement, 5, .production_id = 55), + [1292] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_else_statement, 2), + [1294] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_if_statement_repeat1, 1), + [1296] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abl_statement, 2, .production_id = 1), + [1298] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_abl_statement, 2, .production_id = 1), + [1300] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 2), + [1302] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 2), + [1304] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_assignment, 2), + [1306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_assignment, 2), + [1308] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_call_statement, 2), + [1310] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_call_statement, 2), + [1312] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__if_do_variant, 1), + [1314] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__terminated_statement, 1), + [1316] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__if_then_variant, 1), + [1318] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abl_statement, 3, .production_id = 1), + [1320] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_abl_statement, 3, .production_id = 1), + [1322] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 3), + [1324] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 3), + [1326] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 3), + [1328] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 3), + [1330] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_return_statement, 3), + [1332] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_return_statement, 3), + [1334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__block_terminator, 2), + [1336] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__block_terminator, 2), + [1338] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4), + [1340] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4), + [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 4, .production_id = 13), + [1344] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 4, .production_id = 13), + [1346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 4), + [1348] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 4), + [1350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 5, .production_id = 14), + [1352] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 5, .production_id = 14), + [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5, .production_id = 13), + [1356] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5, .production_id = 13), + [1358] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5), + [1360] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5), + [1362] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 5), + [1364] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 5), + [1366] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 5, .production_id = 24), + [1368] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 5, .production_id = 24), + [1370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 6, .production_id = 14), + [1372] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 6, .production_id = 14), + [1374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6, .production_id = 13), + [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6), + [1378] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6), + [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 6), + [1382] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 6), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 6, .production_id = 37), + [1386] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 6, .production_id = 37), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 6, .production_id = 24), + [1390] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 6, .production_id = 24), + [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [1394] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 7, .production_id = 14), + [1396] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 7, .production_id = 14), + [1398] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7, .production_id = 13), + [1400] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7, .production_id = 13), + [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7), + [1404] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7), + [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 7), + [1410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 7), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 7, .production_id = 37), + [1414] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 7, .production_id = 37), + [1416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 7, .production_id = 24), + [1418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 7, .production_id = 24), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 8, .production_id = 14), + [1422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 8, .production_id = 14), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8, .production_id = 13), + [1426] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8, .production_id = 13), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 8), + [1430] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 8), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 8, .production_id = 37), + [1434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 8, .production_id = 37), + [1436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8, .production_id = 24), + [1438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8, .production_id = 24), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 8), + [1442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 8), + [1444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 9, .production_id = 14), + [1446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 9, .production_id = 14), + [1448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 9, .production_id = 37), + [1450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 9, .production_id = 37), + [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_repeat_statement, 9, .production_id = 24), + [1454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_repeat_statement, 9, .production_id = 24), + [1456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_block, 9), + [1458] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_block, 9), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 10, .production_id = 14), + [1462] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 10, .production_id = 14), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 10, .production_id = 37), + [1466] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 10, .production_id = 37), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 11, .production_id = 14), + [1470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 11, .production_id = 14), + [1472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 11, .production_id = 37), + [1474] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 11, .production_id = 37), + [1476] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 12, .production_id = 14), + [1478] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 12, .production_id = 14), + [1480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 12, .production_id = 37), + [1482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 12, .production_id = 37), + [1484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 13, .production_id = 14), + [1486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 13, .production_id = 14), + [1488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 13, .production_id = 37), + [1490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 13, .production_id = 37), + [1492] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 14, .production_id = 14), + [1494] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 14, .production_id = 14), + [1496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 14, .production_id = 37), + [1500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 14, .production_id = 37), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 15, .production_id = 14), + [1504] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 15, .production_id = 14), + [1506] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 15, .production_id = 37), + [1508] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 15, .production_id = 37), + [1510] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_statement, 16, .production_id = 37), + [1512] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_statement, 16, .production_id = 37), + [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [1516] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_statement, 2), + [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [1522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [1524] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_if_statement_repeat1, 1), + [1526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(174), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_then_variant, 1), + [1530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [1532] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__terminated_statement, 1), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_else_if_statement, 5, .production_id = 55), + [1536] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__if_do_variant, 1), + [1538] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 4), + [1540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 10, .production_id = 45), + [1542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 2), + [1544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 2), + [1546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 9, .production_id = 32), + [1548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 9, .production_id = 32), + [1550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 9), + [1552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 9), + [1554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 9, .production_id = 45), + [1556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 9, .production_id = 45), + [1558] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 10, .production_id = 32), + [1560] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 9, .production_id = 54), + [1562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 9, .production_id = 48), + [1564] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 9), + [1566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 3), + [1568] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 3), + [1570] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 9, .production_id = 52), + [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 3), + [1574] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 3), + [1576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 9, .production_id = 52), + [1578] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 3, .production_id = 8), + [1580] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 3, .production_id = 8), + [1582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 3), + [1584] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 3), + [1586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_scope_statement, 3), + [1588] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_scope_statement, 3), + [1590] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_stream_statement, 4, .production_id = 12), + [1592] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_stream_statement, 4, .production_id = 12), + [1594] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 4), + [1596] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 4), + [1598] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_stream_definition, 4), + [1600] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_stream_definition, 4), + [1602] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 8, .production_id = 54), + [1604] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_stream_statement, 4, .production_id = 12), + [1606] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_stream_statement, 4, .production_id = 12), + [1608] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 8, .production_id = 48), + [1610] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 8, .production_id = 14), + [1612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 4, .production_id = 13), + [1614] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 4, .production_id = 13), + [1616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 4), + [1618] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 8), + [1620] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 8, .production_id = 21), + [1622] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3273), + [1624] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3612), + [1626] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1570), + [1628] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interface_statement, 8, .production_id = 21), + [1630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 4), + [1632] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 4), + [1634] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_terminator, 1), + [1636] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__case_terminator, 1), + [1638] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 4), + [1640] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 4), + [1642] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 9), + [1644] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 8, .production_id = 52), + [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 9, .production_id = 48), + [1648] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 9, .production_id = 54), + [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 4, .production_id = 8), + [1652] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 4, .production_id = 8), + [1654] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_terminator, 1), + [1656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 4, .production_id = 14), + [1658] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 4, .production_id = 14), + [1660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assign_statement, 4), + [1662] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assign_statement, 4), + [1664] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 10, .production_id = 52), + [1666] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 4), + [1668] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 4), + [1670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 10, .production_id = 32), + [1672] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 10), + [1674] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 10, .production_id = 45), + [1676] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 5, .production_id = 18), + [1678] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 5, .production_id = 18), + [1680] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_close_statement, 5, .production_id = 19), + [1682] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_close_statement, 5, .production_id = 19), + [1684] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 8, .production_id = 45), + [1686] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 8, .production_id = 49), + [1688] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 8, .production_id = 43), + [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 5), + [1692] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 5), + [1694] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 8, .production_id = 42), + [1696] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_terminator, 3), + [1698] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__function_terminator, 3), + [1700] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 8, .production_id = 32), + [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 10, .production_id = 52), + [1704] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 8), + [1706] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_parameter_definition, 8), + [1708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 5, .production_id = 18), + [1710] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 5, .production_id = 18), + [1712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_close_statement, 5, .production_id = 19), + [1714] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_close_statement, 5, .production_id = 19), + [1716] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 10, .production_id = 54), + [1718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 5, .production_id = 13), + [1720] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 5, .production_id = 13), + [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 5), + [1724] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 5), + [1726] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface_statement, 5, .production_id = 21), + [1728] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interface_statement, 5, .production_id = 21), + [1730] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 5, .production_id = 21), + [1732] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 5, .production_id = 21), + [1734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 5), + [1736] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 5), + [1738] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5, .production_id = 22), + [1740] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5, .production_id = 22), + [1742] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5), + [1744] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5), + [1746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 5, .production_id = 23), + [1748] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 5, .production_id = 23), + [1750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_statement, 5), + [1752] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_case_statement, 5), + [1754] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 5, .production_id = 8), + [1756] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 5, .production_id = 8), + [1758] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 5, .production_id = 14), + [1760] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 5, .production_id = 14), + [1762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 5), + [1764] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 5), + [1766] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_statement, 7), + [1768] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_catch_statement, 7, .production_id = 48), + [1770] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 7, .production_id = 14), + [1772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 5, .production_id = 24), + [1774] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 5, .production_id = 24), + [1776] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_input_stream_statement, 6, .production_id = 28), + [1778] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_input_stream_statement, 6, .production_id = 28), + [1780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 6, .production_id = 29), + [1782] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 6, .production_id = 29), + [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 6, .production_id = 30), + [1786] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 6, .production_id = 30), + [1788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 6, .production_id = 31), + [1790] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 6, .production_id = 31), + [1792] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 6), + [1794] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 6), + [1796] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 7, .production_id = 8), + [1798] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 10), + [1800] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 10, .production_id = 54), + [1802] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 7), + [1804] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 7, .production_id = 21), + [1806] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interface_statement, 7, .production_id = 21), + [1808] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 11, .production_id = 32), + [1810] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 11, .production_id = 32), + [1812] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 11, .production_id = 45), + [1814] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 11, .production_id = 45), + [1816] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 8, .production_id = 54), + [1818] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 11, .production_id = 52), + [1820] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_statement, 11, .production_id = 52), + [1822] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 8, .production_id = 48), + [1824] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 8, .production_id = 14), + [1826] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 7, .production_id = 45), + [1828] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 8), + [1830] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 7, .production_id = 44), + [1832] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 43), + [1834] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 42), + [1836] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 8, .production_id = 21), + [1838] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface_statement, 8, .production_id = 21), + [1840] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 7, .production_id = 32), + [1842] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_definition, 7), + [1844] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_buffer_definition, 7, .production_id = 40), + [1846] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 30), + [1848] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_variable_definition, 7, .production_id = 29), + [1850] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_parameter_definition, 7), + [1852] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_do_while_statement, 6, .production_id = 24), + [1854] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_statement, 6), + [1856] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_finally_statement, 6), + [1858] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 6, .production_id = 14), + [1860] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_find_statement, 6, .production_id = 8), + [1862] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__case_terminator, 3), + [1864] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_statement, 8, .production_id = 52), + [1866] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 12, .production_id = 45), + [1868] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 12, .production_id = 45), + [1870] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 6, .production_id = 32), + [1872] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_query_definition, 6, .production_id = 32), + [1874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_terminator, 1), + [1876] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 6, .production_id = 35), + [1878] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_undo_statement, 6, .production_id = 22), + [1880] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_statement, 6), + [1882] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_class_statement, 6, .production_id = 21), + [1884] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_interface_statement, 6, .production_id = 21), + [1886] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__procedure_terminator, 3), + [1888] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_procedure_statement, 6), + [1890] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 2, .production_id = 33), + [1892] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_output_stream_statement, 6, .production_id = 28), + [1894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_output_stream_statement, 6, .production_id = 28), + [1896] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_statement, 6), + [1898] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__procedure_terminator, 3), + [1900] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 8, .production_id = 45), + [1902] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 8, .production_id = 49), + [1904] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 8, .production_id = 43), + [1906] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 8, .production_id = 42), + [1908] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 8, .production_id = 32), + [1910] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_while_statement, 6, .production_id = 24), + [1912] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 8), + [1914] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_parameter_definition, 8), + [1916] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1), + [1918] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2519), + [1920] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2071), + [1922] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1687), + [1924] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__loop_statement, 1), + [1926] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__stream_statement, 1), + [1928] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_source_code_repeat1, 1), + [1930] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_statement, 7), + [1932] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2), + [1934] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_catch_statement, 7, .production_id = 48), + [1936] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 7, .production_id = 14), + [1938] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 7, .production_id = 8), + [1940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1), + [1942] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2910), + [1944] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2095), + [1946] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1690), + [1948] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 7), + [1950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface_statement, 6, .production_id = 21), + [1952] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_procedure_parameter_definition, 7), + [1954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__loop_statement, 1), + [1956] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 7, .production_id = 45), + [1958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 29), + [1960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__stream_statement, 1), + [1962] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 7, .production_id = 21), + [1964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 7, .production_id = 44), + [1966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 30), + [1968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface_statement, 7, .production_id = 21), + [1970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 43), + [1972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_definition, 7, .production_id = 42), + [1974] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition, 7, .production_id = 32), + [1976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_class_statement, 6, .production_id = 21), + [1978] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_statement, 6), + [1980] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_statement, 6), + [1982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_finally_statement, 6), + [1984] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 6, .production_id = 22), + [1986] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_undo_statement, 6, .production_id = 35), + [1988] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_terminator, 3), + [1990] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2), + [1992] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_definition, 7), + [1994] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_source_code_repeat1, 1), + [1996] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_buffer_definition, 7, .production_id = 40), + [1998] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 6, .production_id = 8), + [2000] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_find_statement, 6, .production_id = 14), + [2002] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3667), + [2004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1675), + [2006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1509), + [2008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1747), + [2010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3524), + [2012] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3524), + [2014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3552), + [2016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3400), + [2018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3415), + [2020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3667), + [2022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3438), + [2024] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3801), + [2026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3754), + [2028] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3754), + [2030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3755), + [2032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3733), + [2034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3756), + [2036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3801), + [2038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3732), + [2040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [2042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [2044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [2046] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_accumulate_aggregate, 1), + [2048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [2050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [2052] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_primitive_type, 1), + [2054] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_primitive_type, 1), + [2056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [2058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [2060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [2062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [2064] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__comparison_operator, 1), + [2066] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__additive_operator, 1), + [2068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [2070] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__logical_operator, 1), + [2072] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__multiplicative_operator, 1), + [2074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [2076] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 3, .production_id = 33), + [2078] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3085), + [2080] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1495), + [2082] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_access_tuning, 1), + [2084] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_access_tuning, 1), + [2086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [2088] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2987), + [2090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3499), + [2092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3475), + [2094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2138), + [2096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3476), + [2098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3478), + [2100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [2102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [2104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [2106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [2108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [2110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [2112] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [2114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [2116] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 4, .production_id = 33), + [2118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [2120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [2122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(221), + [2124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [2126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [2128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [2130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [2132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [2134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(104), + [2136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [2138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [2140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [2142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [2144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(266), + [2146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [2148] = {.entry = {.count = 1, .reusable = false}}, SHIFT(349), + [2150] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2511), + [2152] = {.entry = {.count = 1, .reusable = false}}, SHIFT(399), + [2154] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2080), + [2156] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1767), + [2158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(387), + [2160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [2162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [2164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [2166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [2168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [2170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(352), + [2172] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2507), + [2174] = {.entry = {.count = 1, .reusable = false}}, SHIFT(481), + [2176] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2045), + [2178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1740), + [2180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(379), + [2182] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 5, .production_id = 33), + [2184] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_of, 2), + [2186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 6, .production_id = 33), + [2188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), + [2190] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), SHIFT(1747), + [2193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3495), + [2195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3532), + [2197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3533), + [2199] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 5, .production_id = 53), + [2201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1748), + [2203] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 5, .production_id = 53), + [2205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3430), + [2207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3432), + [2209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2580), + [2211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3740), + [2213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 6, .production_id = 56), + [2215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1757), + [2217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 6, .production_id = 56), + [2219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2846), + [2221] = {.entry = {.count = 1, .reusable = false}}, SHIFT(347), + [2223] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2505), + [2225] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2066), + [2227] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1731), + [2229] = {.entry = {.count = 1, .reusable = false}}, SHIFT(386), + [2231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 7, .production_id = 58), + [2233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1713), + [2235] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 7, .production_id = 58), + [2237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2898), + [2239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 8, .production_id = 60), + [2241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1721), + [2243] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 8, .production_id = 60), + [2245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2818), + [2247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1175), + [2249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_tuning, 2), + [2251] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1675), + [2254] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1509), + [2257] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), SHIFT_REPEAT(1747), + [2260] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 2), + [2262] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_variable_definition_repeat1, 2), + [2264] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_tuning, 1), + [2266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3534), + [2268] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3534), + [2270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3523), + [2272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1446), + [2274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2078), + [2276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [2278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2047), + [2280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2057), + [2282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2052), + [2284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2050), + [2286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2048), + [2288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1440), + [2290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3761), + [2292] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3761), + [2294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3692), + [2296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1137), + [2298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(268), + [2300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [2302] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 5), + [2304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1718), + [2306] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 5), + [2308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2537), + [2310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(666), + [2312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(654), + [2314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3698), + [2316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(100), + [2318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(440), + [2320] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2533), + [2322] = {.entry = {.count = 1, .reusable = false}}, SHIFT(435), + [2324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2422), + [2326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(667), + [2328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [2330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(928), + [2332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [2334] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 6), + [2336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1768), + [2338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 6), + [2340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2849), + [2342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(790), + [2344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [2346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), + [2348] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 7), + [2350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1715), + [2352] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 7), + [2354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2900), + [2356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(880), + [2358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(877), + [2360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(875), + [2362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(562), + [2364] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), + [2366] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(534), + [2369] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(1644), + [2372] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(3399), + [2375] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(3337), + [2378] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2), SHIFT_REPEAT(2984), + [2381] = {.entry = {.count = 1, .reusable = true}}, SHIFT(557), + [2383] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scope_tuning, 1), + [2385] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scope_tuning, 1), + [2387] = {.entry = {.count = 1, .reusable = true}}, SHIFT(785), + [2389] = {.entry = {.count = 1, .reusable = true}}, SHIFT(554), + [2391] = {.entry = {.count = 1, .reusable = true}}, SHIFT(922), + [2393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(872), + [2395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(784), + [2397] = {.entry = {.count = 1, .reusable = true}}, SHIFT(920), + [2399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(919), + [2401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(567), + [2403] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [2405] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 8), + [2407] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1726), + [2409] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 8), + [2411] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2819), + [2413] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), + [2415] = {.entry = {.count = 1, .reusable = false}}, SHIFT(54), + [2417] = {.entry = {.count = 1, .reusable = false}}, SHIFT(246), + [2419] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_column, 1, .production_id = 20), + [2421] = {.entry = {.count = 1, .reusable = false}}, SHIFT(304), + [2423] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2200), + [2425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3766), + [2427] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), + [2429] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), SHIFT_REPEAT(1644), + [2432] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 2), SHIFT_REPEAT(3399), + [2435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3490), + [2437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [2439] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 9, .production_id = 58), + [2441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1741), + [2443] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 9, .production_id = 58), + [2445] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 8, .production_id = 56), + [2447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1725), + [2449] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 8, .production_id = 56), + [2451] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 10, .production_id = 60), + [2453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1753), + [2455] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 10, .production_id = 60), + [2457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 10), + [2459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1752), + [2461] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 10), + [2463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 9), + [2465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1739), + [2467] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 9), + [2469] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2078), + [2472] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), + [2474] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2047), + [2477] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2057), + [2480] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2052), + [2483] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2050), + [2486] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 2), SHIFT_REPEAT(2048), + [2489] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 7, .production_id = 53), + [2491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1754), + [2493] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 7, .production_id = 53), + [2495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [2497] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), REDUCE(aux_sym_buffer_definition_repeat1, 1), + [2500] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_variable_definition_repeat1, 1), + [2502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 1), + [2504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 8, .production_id = 58), + [2506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 8, .production_id = 58), + [2508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat2, 2), + [2510] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat2, 2), SHIFT_REPEAT(1509), + [2513] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_property_definition_repeat2, 2), + [2515] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat2, 2), SHIFT_REPEAT(3430), + [2518] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat2, 2), SHIFT_REPEAT(3432), + [2521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__pre_tuning, 1), + [2523] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 9, .production_id = 60), + [2525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 9, .production_id = 60), + [2527] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 4, .production_id = 41), + [2529] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), + [2531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2294), + [2533] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2676), + [2535] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 9, .production_id = 56), + [2537] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 9, .production_id = 56), + [2539] = {.entry = {.count = 1, .reusable = false}}, SHIFT(152), + [2541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 2, .production_id = 17), + [2543] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3352), + [2545] = {.entry = {.count = 1, .reusable = false}}, SHIFT(252), + [2547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 7, .production_id = 56), + [2549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 7, .production_id = 56), + [2551] = {.entry = {.count = 1, .reusable = false}}, SHIFT(208), + [2553] = {.entry = {.count = 1, .reusable = false}}, SHIFT(201), + [2555] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 9, .production_id = 53), + [2557] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 9, .production_id = 53), + [2559] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 10, .production_id = 56), + [2561] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 10, .production_id = 56), + [2563] = {.entry = {.count = 1, .reusable = false}}, SHIFT(38), + [2565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 10, .production_id = 58), + [2567] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 10, .production_id = 58), + [2569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 1, .production_id = 17), + [2571] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_serialization_tuning, 1), + [2573] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_serialization_tuning, 1), + [2575] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 6, .production_id = 53), + [2577] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 6, .production_id = 53), + [2579] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 11), + [2581] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 11), + [2583] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 11, .production_id = 58), + [2585] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 11, .production_id = 58), + [2587] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 8, .production_id = 53), + [2589] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 8, .production_id = 53), + [2591] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 11, .production_id = 60), + [2593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 11, .production_id = 60), + [2595] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 12), + [2597] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 12), + [2599] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_definition, 12, .production_id = 60), + [2601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_property_definition, 12, .production_id = 60), + [2603] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3740), + [2606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 2), + [2608] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 2), SHIFT_REPEAT(3352), + [2611] = {.entry = {.count = 1, .reusable = false}}, SHIFT(132), + [2613] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat1, 1), SHIFT(1509), + [2616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3762), + [2618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3763), + [2620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1144), + [2622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2085), + [2624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3158), + [2626] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3155), + [2628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3573), + [2630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3576), + [2632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1448), + [2634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1460), + [2636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3070), + [2638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1238), + [2640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3134), + [2642] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1778), + [2644] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 2), + [2646] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2904), + [2648] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 3), + [2650] = {.entry = {.count = 1, .reusable = false}}, SHIFT(333), + [2652] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2482), + [2654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3742), + [2656] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), SHIFT_REPEAT(1675), + [2659] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), SHIFT_REPEAT(1509), + [2662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_buffer_definition_repeat1, 2), + [2664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2433), + [2666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3260), + [2668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1419), + [2670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3108), + [2672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1367), + [2674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1345), + [2676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2921), + [2678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2417), + [2680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3284), + [2682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1224), + [2684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3518), + [2686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3515), + [2688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1171), + [2690] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3766), + [2693] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2411), + [2695] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3310), + [2697] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1193), + [2699] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3163), + [2701] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat1, 1), + [2703] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1492), + [2705] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inherits, 2), + [2707] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2060), + [2709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [2711] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3243), + [2713] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1521), + [2715] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1692), + [2717] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1161), + [2719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_implements, 2), + [2721] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [2723] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [2725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [2727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3758), + [2729] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [2731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 5), + [2733] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1475), + [2735] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), + [2737] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(465), + [2740] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(2294), + [2743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 2), SHIFT_REPEAT(2676), + [2746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3209), + [2748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1223), + [2750] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_and, 2, .production_id = 6), + [2752] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 5, .production_id = 41), + [2754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1294), + [2756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [2758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [2760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [2762] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_and, 4, .production_id = 15), + [2764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [2766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3274), + [2768] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_first, 4, .production_id = 15), + [2770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3336), + [2772] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__using_first, 2, .production_id = 6), + [2774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2981), + [2776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [2778] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat1, 1, .production_id = 17), + [2780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_definition, 4), + [2782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1368), + [2784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [2786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2533), + [2788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(435), + [2790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2422), + [2792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [2794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [2796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [2798] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1693), + [2800] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_clause, 3), + [2802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [2804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [2806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(597), + [2808] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), SHIFT_REPEAT(1693), + [2811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), + [2813] = {.entry = {.count = 1, .reusable = true}}, SHIFT(676), + [2815] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2061), + [2817] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [2819] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [2821] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_interface_body, 1), + [2823] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_can_find_expression_repeat2, 1), + [2825] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_clause, 2), + [2827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [2829] = {.entry = {.count = 1, .reusable = true}}, SHIFT(345), + [2831] = {.entry = {.count = 1, .reusable = true}}, SHIFT(671), + [2833] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [2835] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_inherits_repeat1, 2), + [2837] = {.entry = {.count = 1, .reusable = true}}, SHIFT(673), + [2839] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [2841] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [2843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [2845] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), + [2847] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_interface_body_repeat1, 2), + [2849] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_interface_body_repeat1, 2), SHIFT_REPEAT(1521), + [2852] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_interface_body_repeat1, 2), SHIFT_REPEAT(1692), + [2855] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_interface_body_repeat1, 2), SHIFT_REPEAT(1161), + [2858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [2860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(365), + [2862] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3742), + [2865] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2072), + [2867] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [2869] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 7, .production_id = 33), + [2871] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [2873] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1156), + [2875] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_field_definition_repeat1, 1), + [2877] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1239), + [2879] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1232), + [2881] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1200), + [2883] = {.entry = {.count = 1, .reusable = true}}, SHIFT(450), + [2885] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2051), + [2887] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1270), + [2889] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1194), + [2891] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter, 3), + [2893] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter, 3), + [2895] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_tuning, 2), + [2897] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_tuning, 2), + [2899] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter, 3), + [2901] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter, 3), + [2903] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1192), + [2905] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1271), + [2907] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1350), + [2909] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1235), + [2911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), + [2913] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), SHIFT_REPEAT(2085), + [2916] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_temp_table_definition_repeat1, 2), SHIFT_REPEAT(3155), + [2919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1351), + [2921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1277), + [2923] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1278), + [2925] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_implements, 3), + [2927] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1279), + [2929] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inherits, 3), + [2931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1431), + [2933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1427), + [2935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3682), + [2937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3557), + [2939] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_inherits_repeat1, 2), SHIFT_REPEAT(2060), + [2942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1424), + [2944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1296), + [2946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1445), + [2948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1443), + [2950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1265), + [2952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1236), + [2954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1473), + [2956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1366), + [2958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), + [2960] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), SHIFT_REPEAT(450), + [2963] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 2), SHIFT_REPEAT(2051), + [2966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_setter, 2), + [2968] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_setter, 2), + [2970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1405), + [2972] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_getter, 2), + [2974] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_getter, 2), + [2976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1348), + [2978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1353), + [2980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1411), + [2982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat2, 1), + [2984] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_property_definition_repeat2, 1), + [2986] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat1, 2), + [2988] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat1, 2), SHIFT_REPEAT(2138), + [2991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1465), + [2993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2444), + [2995] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2791), + [2997] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3813), + [2999] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2490), + [3001] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3778), + [3003] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2380), + [3005] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1267), + [3007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2867), + [3009] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2404), + [3011] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3170), + [3013] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3171), + [3015] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1199), + [3017] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1651), + [3019] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3792), + [3021] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1360), + [3023] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2400), + [3025] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1275), + [3027] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1648), + [3029] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2444), + [3032] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2791), + [3035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), + [3037] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(2490), + [3040] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 2), SHIFT_REPEAT(3778), + [3043] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3810), + [3045] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1343), + [3047] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3145), + [3049] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3146), + [3051] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_definition, 4), + [3053] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1300), + [3055] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3082), + [3057] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3092), + [3059] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 2), + [3061] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 2), SHIFT_REPEAT(2904), + [3064] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 2), SHIFT_REPEAT(1778), + [3067] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1426), + [3069] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3212), + [3071] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3252), + [3073] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3339), + [3075] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3646), + [3077] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3298), + [3079] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3443), + [3081] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3307), + [3083] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3156), + [3085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(46), + [3087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(440), + [3089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(267), + [3091] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_abstract, 1), + [3093] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_final, 1), + [3095] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3487), + [3097] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_widget_pool, 1), + [3099] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_variable_tuning, 1), + [3101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1807), + [3103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3782), + [3105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3465), + [3107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1802), + [3109] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_variable_definition_repeat2, 1), + [3111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1920), + [3113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2968), + [3115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(441), + [3117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2236), + [3119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [3121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1647), + [3123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [3125] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_class_statement_repeat1, 1), + [3127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3564), + [3129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [3131] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), + [3133] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), SHIFT_REPEAT(3631), + [3136] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 2), SHIFT_REPEAT(2232), + [3139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1129), + [3141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3200), + [3143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1114), + [3145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3223), + [3147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_serializable, 1), + [3149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3095), + [3151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [3153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat1, 1), + [3155] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_temp_table_definition_repeat1, 1), + [3157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_temp_table_tuning, 1), + [3159] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_temp_table_tuning, 1), + [3161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1652), + [3163] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3603), + [3165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1197), + [3167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3188), + [3169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [3171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1355), + [3173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3305), + [3175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [3177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(149), + [3179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2266), + [3181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [3183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3302), + [3185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3383), + [3187] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_body, 1), + [3189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1638), + [3191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [3193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3281), + [3195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [3197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1189), + [3199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1274), + [3201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1136), + [3203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1132), + [3205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1181), + [3207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1115), + [3209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1108), + [3211] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1263), + [3213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1281), + [3215] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1323), + [3217] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1346), + [3219] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1447), + [3221] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_property_definition_repeat1, 1), + [3223] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1112), + [3225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1113), + [3227] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_property_tuning, 1), + [3229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [3231] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_phrase, 2), + [3233] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3611), + [3235] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [3237] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_index_tuning, 2), + [3239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1250), + [3241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1251), + [3243] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_phrase, 3), + [3245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2374), + [3247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [3249] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_data_relation_repeat1, 2), + [3251] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_on_statement_repeat1, 2), SHIFT_REPEAT(496), + [3254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [3256] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_sort_clause_repeat1, 1), + [3258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [3260] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_column, 2, .production_id = 20), + [3262] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_sort_order, 1), + [3264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [3266] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), SHIFT_REPEAT(2251), + [3269] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), + [3271] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 2), SHIFT_REPEAT(3611), + [3274] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_do_block_repeat1, 2), + [3276] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_do_block_repeat1, 2), SHIFT_REPEAT(2422), + [3279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), + [3281] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), SHIFT_REPEAT(2867), + [3284] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 2), SHIFT_REPEAT(2404), + [3287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), + [3289] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), SHIFT_REPEAT(3573), + [3292] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 2), SHIFT_REPEAT(3576), + [3295] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [3297] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_index_definition_repeat1, 1), + [3299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [3301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1299), + [3303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1184), + [3305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1693), + [3307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3457), + [3309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 2), + [3311] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 2), SHIFT_REPEAT(441), + [3314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3652), + [3316] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1109), + [3318] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3800), + [3320] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_phrase_repeat2, 1), + [3322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [3324] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1408), + [3326] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3643), + [3328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [3330] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 2), SHIFT_REPEAT(3652), + [3333] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 2), + [3335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3327), + [3337] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3241), + [3339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3113), + [3341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1857), + [3343] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [3345] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [3347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [3349] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1441), + [3351] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3571), + [3353] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 1), + [3355] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3587), + [3357] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [3359] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_on_statement_repeat2, 2), + [3361] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_on_statement_repeat2, 2), SHIFT_REPEAT(3509), + [3364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3609), + [3366] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1140), + [3368] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3444), + [3370] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_fields, 3), + [3372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3369), + [3374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3370), + [3376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3371), + [3378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1875), + [3380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [3382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [3384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3057), + [3386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3149), + [3388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3058), + [3390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [3392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 8, .production_id = 33), + [3394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [3396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [3398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3096), + [3400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3282), + [3402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3097), + [3404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [3406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [3408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [3410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2475), + [3412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2474), + [3414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [3416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_fields, 2), + [3418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 2), + [3420] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3530), + [3422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [3424] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_data_relation_repeat1, 2), SHIFT_REPEAT(3302), + [3427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3280), + [3429] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2513), + [3431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2406), + [3433] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3204), + [3435] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2379), + [3437] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2378), + [3439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [3441] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2407), + [3443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3416), + [3445] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [3447] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [3449] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [3451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2521), + [3453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [3455] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [3457] = {.entry = {.count = 1, .reusable = true}}, SHIFT(140), + [3459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3397), + [3461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [3463] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [3465] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [3467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), + [3469] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dataset_definition, 10), + [3471] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dataset_definition, 10), + [3473] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 9, .production_id = 33), + [3475] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_to_phrase, 5), + [3477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [3479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 7, .production_id = 50), + [3481] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2919), + [3483] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 5), + [3485] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 7), + [3487] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 7), + [3489] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3712), + [3491] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3703), + [3493] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3701), + [3495] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), + [3497] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [3499] = {.entry = {.count = 1, .reusable = false}}, SHIFT(154), + [3501] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3259), + [3503] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3270), + [3505] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2383), + [3507] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 7, .production_id = 23), + [3509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 11), + [3511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 11), + [3513] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3293), + [3515] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2897), + [3517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3246), + [3519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2986), + [3521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 5), + [3523] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2395), + [3525] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_error_phrase, 5), + [3527] = {.entry = {.count = 1, .reusable = false}}, SHIFT(84), + [3529] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3367), + [3531] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2365), + [3533] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2765), + [3535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 6), + [3537] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [3539] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 9, .production_id = 59), + [3541] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 9, .production_id = 59), + [3543] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2784), + [3545] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_quit_phrase, 4), + [3547] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 12), + [3549] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 12), + [3551] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3226), + [3553] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2790), + [3555] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [3557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 10), + [3559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 10), + [3561] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2966), + [3563] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [3565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6, .production_id = 46), + [3567] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6), + [3569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dataset_definition, 7), + [3571] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dataset_definition, 7), + [3573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dataset_definition, 9), + [3575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dataset_definition, 9), + [3577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 9), + [3579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 9), + [3581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_definition_repeat1, 1), + [3583] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [3585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition_tuning, 1), + [3587] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [3589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_error_phrase, 6, .production_id = 23), + [3591] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2364), + [3593] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_error_phrase, 6, .production_id = 23), + [3595] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [3597] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3355), + [3599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3169), + [3601] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [3603] = {.entry = {.count = 1, .reusable = false}}, SHIFT(60), + [3605] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3065), + [3607] = {.entry = {.count = 1, .reusable = false}}, SHIFT(199), + [3609] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3164), + [3611] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [3613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_do_tuning, 1), + [3615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 5), + [3617] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3694), + [3619] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3695), + [3621] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3655), + [3623] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [3625] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3690), + [3627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3691), + [3629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3661), + [3631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(432), + [3633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_do_block_repeat1, 1), + [3635] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 8, .production_id = 59), + [3637] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 8, .production_id = 59), + [3639] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 8, .production_id = 57), + [3641] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 8, .production_id = 57), + [3643] = {.entry = {.count = 1, .reusable = false}}, SHIFT(899), + [3645] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2882), + [3647] = {.entry = {.count = 1, .reusable = false}}, SHIFT(871), + [3649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_event_definition, 8), + [3651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_event_definition, 8), + [3653] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [3655] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2879), + [3657] = {.entry = {.count = 1, .reusable = false}}, SHIFT(892), + [3659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), + [3661] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dataset_definition, 8), + [3663] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dataset_definition, 8), + [3665] = {.entry = {.count = 1, .reusable = false}}, SHIFT(893), + [3667] = {.entry = {.count = 1, .reusable = false}}, SHIFT(643), + [3669] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_query_definition_tuning, 2), + [3671] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1, .production_id = 2), + [3673] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1, .production_id = 2), + [3675] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1), + [3677] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1), + [3679] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include_argument, 1, .production_id = 3), + [3681] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_include_argument, 1, .production_id = 3), + [3683] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_include_repeat1, 1), + [3685] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_include_repeat1, 1), + [3687] = {.entry = {.count = 1, .reusable = false}}, SHIFT(548), + [3689] = {.entry = {.count = 1, .reusable = false}}, SHIFT(558), + [3691] = {.entry = {.count = 1, .reusable = false}}, SHIFT(212), + [3693] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3207), + [3695] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_widget_phrase_repeat1, 1), + [3697] = {.entry = {.count = 1, .reusable = false}}, SHIFT(297), + [3699] = {.entry = {.count = 1, .reusable = false}}, SHIFT(644), + [3701] = {.entry = {.count = 1, .reusable = false}}, SHIFT(907), + [3703] = {.entry = {.count = 1, .reusable = false}}, SHIFT(653), + [3705] = {.entry = {.count = 1, .reusable = false}}, SHIFT(909), + [3707] = {.entry = {.count = 1, .reusable = false}}, SHIFT(298), + [3709] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [3711] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_widget_field, 4), + [3713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 7, .production_id = 59), + [3715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 7, .production_id = 59), + [3717] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), + [3719] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3052), + [3721] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 7, .production_id = 57), + [3723] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 7, .production_id = 57), + [3725] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), + [3727] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3636), + [3729] = {.entry = {.count = 1, .reusable = false}}, SHIFT(904), + [3731] = {.entry = {.count = 1, .reusable = false}}, SHIFT(829), + [3733] = {.entry = {.count = 1, .reusable = false}}, SHIFT(908), + [3735] = {.entry = {.count = 1, .reusable = false}}, SHIFT(777), + [3737] = {.entry = {.count = 1, .reusable = false}}, SHIFT(294), + [3739] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), + [3741] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [3743] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_on_statement_repeat1, 2), SHIFT_REPEAT(514), + [3746] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 2), + [3748] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 2), SHIFT_REPEAT(2882), + [3751] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 2), SHIFT_REPEAT(2879), + [3754] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 2), + [3756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2925), + [3758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [3760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3720), + [3762] = {.entry = {.count = 1, .reusable = false}}, SHIFT(552), + [3764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_interface_body_repeat1, 1), + [3766] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_interface_body_repeat1, 1), + [3768] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2442), + [3770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2386), + [3772] = {.entry = {.count = 1, .reusable = false}}, SHIFT(551), + [3774] = {.entry = {.count = 1, .reusable = false}}, SHIFT(796), + [3776] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2463), + [3778] = {.entry = {.count = 1, .reusable = false}}, SHIFT(813), + [3780] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_method_definition, 6, .production_id = 57), + [3782] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_method_definition, 6, .production_id = 57), + [3784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3591), + [3786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3629), + [3788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3630), + [3790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(444), + [3792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3420), + [3794] = {.entry = {.count = 1, .reusable = false}}, SHIFT(629), + [3796] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3669), + [3798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3129), + [3800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2959), + [3802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2999), + [3804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3000), + [3806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3004), + [3808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3005), + [3810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3011), + [3812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3012), + [3814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2364), + [3816] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2844), + [3818] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3138), + [3820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3278), + [3822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2214), + [3824] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2528), + [3826] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2980), + [3828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3390), + [3830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3019), + [3832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3737), + [3834] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2996), + [3836] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3737), + [3838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2395), + [3840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3032), + [3842] = {.entry = {.count = 1, .reusable = false}}, SHIFT(377), + [3844] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3653), + [3846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2504), + [3848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2064), + [3850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1732), + [3852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3010), + [3854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(550), + [3856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [3858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [3860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2506), + [3862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2046), + [3864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1729), + [3866] = {.entry = {.count = 1, .reusable = false}}, SHIFT(342), + [3868] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3697), + [3870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3119), + [3872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3707), + [3874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3497), + [3876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3043), + [3878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2940), + [3880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [3882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(330), + [3884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1816), + [3886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3767), + [3888] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3049), + [3890] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3767), + [3892] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_call_arguments, 2), + [3894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [3896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(326), + [3898] = {.entry = {.count = 1, .reusable = false}}, SHIFT(721), + [3900] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3492), + [3902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), + [3904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [3906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3795), + [3908] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3062), + [3910] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3795), + [3912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [3914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [3916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [3918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [3920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2509), + [3922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2091), + [3924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1727), + [3926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3487), + [3928] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), + [3930] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), SHIFT_REPEAT(1834), + [3933] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__case_branch_body, 1), + [3935] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [3937] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), + [3939] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_temp_table_definition_repeat2, 1), + [3941] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_when_branch, 4, .production_id = 47), + [3943] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1237), + [3945] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [3947] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [3949] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [3951] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [3953] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2616), + [3955] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3126), + [3957] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [3959] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_qualified_name_repeat1, 2), SHIFT_REPEAT(3747), + [3962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3545), + [3964] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3178), + [3966] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3545), + [3968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1349), + [3970] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3634), + [3972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1834), + [3974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [3976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [3978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [3980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [3982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__function_call_arguments_repeat1, 2), + [3984] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__function_call_arguments_repeat1, 2), SHIFT_REPEAT(346), + [3987] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3594), + [3989] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [3991] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [3993] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [3995] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [3997] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3177), + [3999] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_for_statement_repeat1, 2), SHIFT_REPEAT(2480), + [4002] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_for_statement_repeat1, 2), + [4004] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2714), + [4006] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3338), + [4008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3294), + [4010] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2262), + [4012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3747), + [4014] = {.entry = {.count = 1, .reusable = false}}, SHIFT(718), + [4016] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3404), + [4018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(931), + [4020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [4022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [4024] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2302), + [4026] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3547), + [4028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [4030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1347), + [4032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [4034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [4036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(334), + [4038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [4040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3429), + [4042] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3343), + [4044] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3429), + [4046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(264), + [4048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [4050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [4052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [4054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2328), + [4056] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3397), + [4058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [4060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3392), + [4062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3738), + [4064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1472), + [4066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [4068] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 7), + [4070] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 7, .production_id = 51), + [4072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2346), + [4074] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3386), + [4076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [4078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [4080] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_function_statement_repeat1, 2), + [4082] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_function_statement_repeat1, 2), SHIFT_REPEAT(2214), + [4085] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [4087] = {.entry = {.count = 1, .reusable = true}}, SHIFT(119), + [4089] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [4091] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [4093] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [4095] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 5, .production_id = 34), + [4097] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 5), + [4099] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [4101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3782), + [4103] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3325), + [4105] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_stop_phrase, 5), + [4107] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3665), + [4109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3239), + [4111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3665), + [4113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(115), + [4115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(113), + [4117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [4119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [4121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1276), + [4123] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_on_statement_repeat2, 1), + [4125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1269), + [4127] = {.entry = {.count = 1, .reusable = false}}, SHIFT(857), + [4129] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3535), + [4131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(645), + [4133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3318), + [4135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2958), + [4137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3759), + [4139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [4141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1430), + [4143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3673), + [4145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3453), + [4147] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2815), + [4149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3148), + [4151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [4153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [4155] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3482), + [4157] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [4159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3498), + [4161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3346), + [4163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [4165] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_call_arguments, 1), + [4167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [4169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2708), + [4171] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3107), + [4173] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 6), + [4175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [4177] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_quoted_string_repeat1, 1), + [4179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_case_body_repeat1, 1), + [4181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_double_quoted_string_repeat1, 1), + [4183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [4185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3632), + [4187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3031), + [4189] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3632), + [4191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3316), + [4193] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_on_stop_phrase, 6, .production_id = 23), + [4195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1191), + [4197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3603), + [4199] = {.entry = {.count = 1, .reusable = false}}, SHIFT(772), + [4201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3677), + [4203] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2161), + [4205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3380), + [4207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3287), + [4209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(901), + [4211] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_query_fields_repeat1, 2), SHIFT_REPEAT(3294), + [4214] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_query_fields_repeat1, 2), + [4216] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_assign_statement_repeat1, 1), + [4218] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_quit_phrase, 6, .production_id = 46), + [4220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3599), + [4222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2019), + [4224] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1513), + [4226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1513), + [4228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3568), + [4230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1318), + [4232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1526), + [4234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3300), + [4236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3503), + [4238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [4240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1641), + [4242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1216), + [4244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3502), + [4246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [4248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [4250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1467), + [4252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3458), + [4254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [4256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3785), + [4258] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2264), + [4260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2765), + [4262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1151), + [4264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3764), + [4266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1515), + [4268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1515), + [4270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3806), + [4272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2175), + [4274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1635), + [4276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2527), + [4278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1213), + [4280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3467), + [4282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(767), + [4284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1872), + [4286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3391), + [4288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1153), + [4290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3393), + [4292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2919), + [4294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(768), + [4296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3381), + [4298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [4300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1530), + [4302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3288), + [4304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1149), + [4306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3396), + [4308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2536), + [4310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2863), + [4312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3480), + [4314] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3480), + [4316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2544), + [4318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(973), + [4320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(981), + [4322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2637), + [4324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1012), + [4326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1021), + [4328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2713), + [4330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3464), + [4332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1049), + [4334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1056), + [4336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2783), + [4338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1539), + [4340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3620), + [4342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1084), + [4344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1639), + [4346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1532), + [4348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3663), + [4350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3559), + [4352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [4354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1646), + [4356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), + [4358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3556), + [4360] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3556), + [4362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1098), + [4364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1508), + [4366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3186), + [4368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(831), + [4370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3541), + [4372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(439), + [4374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3540), + [4376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2883), + [4378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3702), + [4380] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2274), + [4382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3488), + [4384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3676), + [4386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3526), + [4388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(445), + [4390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3525), + [4392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2412), + [4394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3084), + [4396] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 2), + [4398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3412), + [4400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2382), + [4402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3751), + [4404] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3751), + [4406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(114), + [4408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3550), + [4410] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2388), + [4412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3456), + [4414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3038), + [4416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3427), + [4418] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2316), + [4420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1230), + [4422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3770), + [4424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3787), + [4426] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3787), + [4428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(741), + [4430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [4432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2099), + [4434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3658), + [4436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2027), + [4438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(726), + [4440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1531), + [4442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3197), + [4444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2701), + [4446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3602), + [4448] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2334), + [4450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3600), + [4452] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2376), + [4454] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_accumulate_statement_repeat1, 2), + [4456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3459), + [4458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3543), + [4460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1248), + [4462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3799), + [4464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(369), + [4466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1170), + [4468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3577), + [4470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2802), + [4472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2024), + [4474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1403), + [4476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3582), + [4478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1249), + [4480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3797), + [4482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1525), + [4484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3753), + [4486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3387), + [4488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3510), + [4490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), + [4492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2755), + [4494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1429), + [4496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3614), + [4498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1096), + [4500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3516), + [4502] = {.entry = {.count = 1, .reusable = true}}, SHIFT(820), + [4504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2021), + [4506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2641), + [4508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1432), + [4510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3622), + [4512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1516), + [4514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3531), + [4516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1264), + [4518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3607), + [4520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2899), + [4522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3450), + [4524] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1454), + [4526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1261), + [4528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3624), + [4530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1433), + [4532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3433), + [4534] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1954), + [4536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(4), + [4538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2022), + [4540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3410), + [4542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2014), + [4544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [4546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3711), + [4548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3721), + [4550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1518), + [4552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3020), + [4554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 5), + [4556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2784), + [4558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3505), + [4560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3588), + [4562] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3588), + [4564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3375), + [4566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3389), + [4568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1636), + [4570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1722), + [4572] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2137), + [4574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2396), + [4576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3650), + [4578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), + [4580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [4582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_accumulate_aggregate, 1), + [4584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3651), + [4586] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 4), + [4588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(383), + [4590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1450), + [4592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3590), + [4594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3360), + [4596] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__function_argument_with_mode, 2), + [4598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3769), + [4600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3757), + [4602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3654), + [4604] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3654), + [4606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3521), + [4608] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1218), + [4610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1511), + [4612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2977), + [4614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1423), + [4616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3579), + [4618] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2871), + [4620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [4622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2013), + [4624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2764), + [4626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1384), + [4628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3385), + [4630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1383), + [4632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3382), + [4634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [4636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2371), + [4638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3446), + [4640] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1379), + [4642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2023), + [4644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(933), + [4646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1640), + [4648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1514), + [4650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3214), + [4652] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2928), + [4654] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3804), + [4656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3317), + [4658] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_query_fields_repeat1, 1), + [4660] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_query_fields_repeat1, 1), + [4662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1178), + [4664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3419), + [4666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2259), + [4668] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_parameter_mode, 1), + [4670] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_parameter, 3), + [4672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2180), + [4674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [4676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2016), + [4678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1365), + [4680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3481), + [4682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 7, .production_id = 50), + [4684] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 7, .production_id = 23), + [4686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [4688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(717), + [4690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1308), + [4692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3625), + [4694] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 6, .production_id = 46), + [4696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(743), + [4698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3513), + [4700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), + [4702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_phrase, 10, .production_id = 33), + [4704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1225), + [4706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3551), + [4708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1309), + [4710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3605), + [4712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1625), + [4714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2610), + [4716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1522), + [4718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3045), + [4720] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3402), + [4722] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3402), + [4724] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2487), + [4726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3047), + [4728] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1831), + [4730] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3709), + [4732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2785), + [4734] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_on_stop_phrase, 6), + [4736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1119), + [4738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3644), + [4740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [4742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3647), + [4744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3688), + [4746] = {.entry = {.count = 1, .reusable = false}}, SHIFT(1163), + [4748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1955), + [4750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [4752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [4754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [4756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2428), + [4758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [4760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3296), + [4762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2397), + [4764] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data_relation, 6), + [4766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1310), + [4768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1805), + [4770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1953), + [4772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2429), + [4774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3713), + [4776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2387), + [4778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1121), + [4780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(633), + [4782] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data_relation, 7), + [4784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [4786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1642), + [4788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1771), + [4790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(821), + [4792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3326), + [4794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [4796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [4798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [4800] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1027), + [4802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2370), + [4804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [4806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3555), + [4808] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data_relation, 8), + [4810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(770), + [4812] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_data_relation, 9), + [4814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [4816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(916), + [4818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [4820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(762), + [4822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2325), + [4824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [4826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(830), + [4828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2003), + [4830] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [4832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1999), + [4834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2439), + [4836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1020), + [4838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [4840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3538), + [4842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1019), + [4844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [4846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [4848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2928), + [4850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1176), + [4852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1765), + [4854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1302), + [4856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [4858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3335), + [4860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1372), + [4862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [4864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2741), + [4866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [4868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [4870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1377), + [4872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1474), + [4874] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1297), + [4876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [4878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [4880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [4882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1344), + [4884] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2464), + [4886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), + [4888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1855), + [4890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [4892] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [4894] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [4896] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [4898] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3489), + [4900] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3242), + [4902] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2088), + [4904] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3232), + [4906] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [4908] = {.entry = {.count = 1, .reusable = true}}, SHIFT(570), + [4910] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1292), + [4912] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1291), + [4914] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3561), + [4916] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [4918] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2434), + [4920] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2049), + [4922] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2976), + [4924] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1786), + [4926] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3072), + [4928] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3140), + [4930] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3741), + [4932] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3056), + [4934] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3059), + [4936] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1780), + [4938] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3699), + [4940] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2423), + [4942] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3127), + [4944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1196), + [4946] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2575), + [4948] = {.entry = {.count = 1, .reusable = true}}, SHIFT(464), + [4950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2149), + [4952] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1186), + [4954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1716), + [4956] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1456), + [4958] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3623), + [4960] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1187), + [4962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3068), + [4964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3617), + [4966] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2746), + [4968] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1524), + [4970] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1457), + [4972] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2740), + [4974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1794), + [4976] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3141), + [4978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1413), + [4980] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1415), + [4982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3365), + [4984] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3501), + [4986] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1988), + [4988] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3034), + [4990] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3040), + [4992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3116), + [4994] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3131), + [4996] = {.entry = {.count = 1, .reusable = true}}, SHIFT(664), + [4998] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1145), + [5000] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1420), + [5002] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1422), + [5004] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [5006] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1304), + [5008] = {.entry = {.count = 1, .reusable = true}}, SHIFT(917), + [5010] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1453), + [5012] = {.entry = {.count = 1, .reusable = true}}, SHIFT(760), + [5014] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [5016] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2375), + [5018] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1455), + [5020] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3578), + [5022] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [5024] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2990), + [5026] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3604), + [5028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [5030] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3166), + [5032] = {.entry = {.count = 1, .reusable = true}}, SHIFT(940), + [5034] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [5036] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2985), + [5038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2070), + [5040] = {.entry = {.count = 1, .reusable = true}}, SHIFT(897), + [5042] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [5044] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2492), + [5046] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [5048] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2631), + [5050] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3106), + [5052] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1444), + [5054] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [5056] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3077), + [5058] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2359), + [5060] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3628), + [5062] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1776), + [5064] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1242), + [5066] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2635), + [5068] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [5070] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [5072] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [5074] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [5076] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3520), + [5078] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3724), + [5080] = {.entry = {.count = 1, .reusable = true}}, SHIFT(910), + [5082] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3205), + [5084] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3101), + [5086] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3114), + [5088] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2373), + [5090] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [5092] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [5094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [5096] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [5098] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2392), + [5100] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2314), + [5102] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2390), + [5104] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2031), + [5106] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1169), + [5108] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1461), + [5110] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2771), + [5112] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_otherwise_branch, 2, .production_id = 36), + [5114] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2306), + [5116] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [5118] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1272), + [5120] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [5122] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [5124] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2514), + [5126] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2017), + [5128] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [5130] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1950), + [5132] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3142), + [5134] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1273), + [5136] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3798), + [5138] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [5140] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [5142] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2054), + [5144] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3210), + [5146] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1128), + [5148] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2222), + [5150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), + [5152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3324), + [5154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1397), + [5156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [5158] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1442), + [5160] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3554), + [5162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(771), + [5164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [5166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1441), + [5168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1203), + [5170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [5172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2366), + [5174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1219), + [5176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(913), + [5178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1201), + [5180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1202), + [5182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [5184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3215), + [5186] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2419), + [5188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1436), + [5190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3229), + [5192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2029), + [5194] = {.entry = {.count = 1, .reusable = true}}, SHIFT(948), + [5196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(303), + [5198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(368), + [5200] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1435), + [5202] = {.entry = {.count = 1, .reusable = true}}, SHIFT(797), + [5204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2006), + [5206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(703), + [5208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2448), + [5210] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_body, 2), + [5212] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3586), + [5214] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_mode, 1), + [5216] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2963), + [5218] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [5220] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3311), + [5222] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1229), + [5224] = {.entry = {.count = 1, .reusable = true}}, SHIFT(939), + [5226] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2988), + [5228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [5230] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3167), + [5232] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [5234] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3811), + [5236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3024), + [5238] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3704), + [5240] = {.entry = {.count = 1, .reusable = true}}, SHIFT(271), + [5242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1220), + [5244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2416), + [5246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3036), + [5248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3037), + [5250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1782), + [5252] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3041), + [5254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3042), + [5256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [5258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3331), + [5260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), + [5262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3517), + [5264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1124), + [5266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2283), + [5268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3130), + [5270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2079), + [5272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2870), + [5274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3657), + [5276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3083), + [5278] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1870), + [5280] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3470), + [5282] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2053), + [5284] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3121), + [5286] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1860), + [5288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1538), + [5290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [5292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2853), + [5294] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3618), + [5296] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), + [5298] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3477), + [5300] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [5302] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2462), + [5304] = {.entry = {.count = 1, .reusable = true}}, SHIFT(543), + [5306] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2369), + [5308] = {.entry = {.count = 1, .reusable = true}}, SHIFT(520), + [5310] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1410), + [5312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [5314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3608), + [5316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1773), + [5318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2381), + [5320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2452), + [5322] = {.entry = {.count = 1, .reusable = true}}, SHIFT(569), + [5324] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2385), + [5326] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2418), + [5328] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1774), + [5330] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3199), + [5332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1985), + [5334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2034), + [5336] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2465), + [5338] = {.entry = {.count = 1, .reusable = true}}, SHIFT(856), + [5340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(861), + [5342] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3244), + [5344] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1409), + [5346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(859), + [5348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2043), + [5350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(866), + [5352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1921), + [5354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1984), + [5356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3021), + [5358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3705), + [5360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3706), + [5362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1902), + [5364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2466), + [5366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3715), + [5368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3017), + [5370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3717), + [5372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3718), + [5374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1458), + [5376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2044), + [5378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1846), + [5380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(869), + [5382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3812), + [5384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2040), + [5386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2922), + [5388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1111), + [5390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [5392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1110), + [5394] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [5396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3466), + [5398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(269), + [5400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3802), + [5402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2398), + [5404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2399), + [5406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(635), + [5408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3786), + [5410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2235), + [5412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2062), + [5414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(641), + [5416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(636), + [5418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(549), + [5420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(896), + [5422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2974), + [5424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__find_type, 1), + [5426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(864), + [5428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2989), + [5430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(658), + [5432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3216), + [5434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1162), + [5436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2037), + [5438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1160), + [5440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1140), + [5442] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3760), + [5444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2687), + [5446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2517), + [5448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3291), + [5450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(1141), + [5452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2028), + [5454] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3768), + [5456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(3803), + [5458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 3), + [5460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 2), + [5462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 3), + [5464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_include, 4), }; #ifdef __cplusplus diff --git a/test/corpus/basic.txt b/test/corpus/basic.txt index 7e97720..11d3275 100644 --- a/test/corpus/basic.txt +++ b/test/corpus/basic.txt @@ -686,36 +686,39 @@ END. -------------------------------------------------------------------------------- (source_code - (do_statement - (assignment - (identifier) + (do_block + (to_phrase + (assignment + (identifier) + (number_literal)) (number_literal)) - (number_literal) (body (variable_assignment (assignment (identifier) (number_literal))))) - (do_statement - (assignment - (identifier) - (number_literal)) - (function_call - (identifier) - (function_call_argument - (double_quoted_string))) + (do_block + (to_phrase + (assignment + (identifier) + (number_literal)) + (function_call + (identifier) + (function_call_argument + (double_quoted_string)))) (body (variable_assignment (assignment (identifier) (number_literal))))) - (do_statement + (do_block (label (identifier)) - (assignment - (identifier) + (to_phrase + (assignment + (identifier) + (number_literal)) (number_literal)) - (number_literal) (body (abl_statement (identifier) @@ -813,7 +816,8 @@ END. -------------------------------------------------------------------------------- (source_code - (transaction_statement + (do_block + (do_tuning) (body (abl_statement statement: (identifier) @@ -1384,7 +1388,8 @@ END. -------------------------------------------------------------------------------- (source_code - (transaction_statement + (do_block + (do_tuning) (body (catch_statement variable: (identifier) @@ -1445,7 +1450,8 @@ instance = NEW z(). type: (primitive_type)))) (class_statement name: (identifier) - inherits: (identifier) + (inherits + (identifier)) (final) (serializable) (body @@ -1695,3 +1701,103 @@ DISPLAY Order.CustNum Order.OrderDate Andsomething AndBug. (identifier)) (identifier) (identifier))) + +================================================================================ +INTERFACE statement +================================================================================ + +INTERFACE r-ICustObj: + + /* Property prototypes to return basic values for the Customer + identified with the highest balance in the database */ + DEFINE PUBLIC PROPERTY HighCustBalance AS DECIMAL NO-UNDO + GET. + SET. + DEFINE PUBLIC PROPERTY HighCustNum AS INTEGER NO-UNDO + GET. + SET. + + /* Event prototype to notify about Customers with Invoices */ + DEFINE PUBLIC EVENT CustHasInvoices + SIGNATURE VOID ( piCustNum AS INTEGER ). + + /* Temp-tables for the ProDataSet parameter */ + DEFINE TEMP-TABLE ttCust NO-UNDO LIKE Customer. + DEFINE TEMP-TABLE ttInv NO-UNDO LIKE Invoice. + + /* ProDataSet parameter for passing a single Customer with the highest + balance along with its related Invoices */ + DEFINE DATASET dsHighCustData FOR ttCust, ttInv + DATA-RELATION FOR ttCust, ttInv + RELATION-FIELDS (ttCust.CustNum, ttInv.CustNum). + + /* Method prototype to get the current high Customer balance data */ + METHOD PUBLIC VOID GetHighCustomerData + ( OUTPUT DATASET dsHighCustData BIND ). + + /* Method prototype to set (or reset) the current high Customer data */ + METHOD PUBLIC VOID SetHighCustomerData ( ). +END INTERFACE. + +-------------------------------------------------------------------------------- + +(source_code + (interface_statement + (identifier) + (comment) + (interface_body + (property_definition + (access_tuning) + (identifier) + (primitive_type) + (getter) + (setter)) + (property_definition + (access_tuning) + (identifier) + (primitive_type) + (getter) + (setter)) + (comment) + (event_definition + (access_tuning) + (identifier) + (function_parameter + (identifier) + (primitive_type))) + (comment) + (temp_table_definition + (identifier) + (temp_table_tuning) + (identifier)) + (temp_table_definition + (identifier) + (temp_table_tuning) + (identifier)) + (comment) + (dataset_definition + (identifier) + (identifier) + (identifier) + (data_relation + (identifier) + (identifier) + (qualified_name + (identifier) + (identifier)) + (qualified_name + (identifier) + (identifier)))) + (comment) + (method_definition + (access_tuning) + (primitive_type) + (identifier) + (function_parameter + (function_parameter_mode) + (identifier))) + (comment) + (method_definition + (access_tuning) + (primitive_type) + (identifier)))))